From 72affcf09b685f03142bb51f1c508895e796686e Mon Sep 17 00:00:00 2001
From: Alexander Nozik <altavir@gmail.com>
Date: Mon, 22 Feb 2021 21:04:08 +0300
Subject: [PATCH 01/37] update build tools

---
 README.md           | 4 ++--
 settings.gradle.kts | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index e524e1cf3..e9cf64ea0 100644
--- a/README.md
+++ b/README.md
@@ -256,8 +256,8 @@ repositories {
 }
 
 dependencies {
-    api("kscience.kmath:kmath-core:0.2.0")
-    // api("kscience.kmath:kmath-core-jvm:0.2.0") for jvm-specific version
+    api("kscience.kmath:kmath-core:() -> kotlin.Any")
+    // api("kscience.kmath:kmath-core-jvm:() -> kotlin.Any") for jvm-specific version
 }
 ```
 
diff --git a/settings.gradle.kts b/settings.gradle.kts
index ce6eb339a..cadbfd7ba 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -7,7 +7,7 @@ pluginManagement {
         maven("https://dl.bintray.com/kotlin/kotlinx")
     }
 
-    val toolsVersion = "0.8.0"
+    val toolsVersion = "0.8.1"
     val kotlinVersion = "1.4.30"
 
     plugins {
-- 
2.34.1


From 9f663ae7f71e6c958d0c8114945d24cb29fcc7e7 Mon Sep 17 00:00:00 2001
From: Iaroslav Postovalov <postovalovya@gmail.com>
Date: Fri, 26 Feb 2021 21:50:06 +0700
Subject: [PATCH 02/37] Update dependencies

---
 kmath-ast/build.gradle.kts                           | 12 +++++++-----
 .../kotlin/space/kscience/kmath/ast/parser.kt        |  8 ++++----
 2 files changed, 11 insertions(+), 9 deletions(-)

diff --git a/kmath-ast/build.gradle.kts b/kmath-ast/build.gradle.kts
index 894279695..5b764459c 100644
--- a/kmath-ast/build.gradle.kts
+++ b/kmath-ast/build.gradle.kts
@@ -33,21 +33,23 @@ kotlin.sourceSets {
 
     jsMain {
         dependencies {
-            implementation(npm("astring", "1.4.3"))
+            implementation(npm("astring", "1.7.0"))
         }
     }
 
     jvmMain {
         dependencies {
-            api("com.github.h0tk3y.betterParse:better-parse:0.4.0")
-            implementation("org.ow2.asm:asm:9.0")
-            implementation("org.ow2.asm:asm-commons:9.0")
+            api("com.github.h0tk3y.betterParse:better-parse:0.4.1")
+            implementation("org.ow2.asm:asm:9.1")
+            implementation("org.ow2.asm:asm-commons:9.1")
         }
     }
 }
 
 //Workaround for https://github.com/Kotlin/dokka/issues/1455
-tasks.getByName("dokkaHtml").dependsOn(tasks.getByName("build"))
+tasks.dokkaHtml {
+    dependsOn(tasks.build)
+}
 
 readme {
     maturity = Maturity.PROTOTYPE
diff --git a/kmath-ast/src/jvmMain/kotlin/space/kscience/kmath/ast/parser.kt b/kmath-ast/src/jvmMain/kotlin/space/kscience/kmath/ast/parser.kt
index 4d8204383..be4aff34f 100644
--- a/kmath-ast/src/jvmMain/kotlin/space/kscience/kmath/ast/parser.kt
+++ b/kmath-ast/src/jvmMain/kotlin/space/kscience/kmath/ast/parser.kt
@@ -1,4 +1,4 @@
-// TODO move to common when https://github.com/h0tk3y/better-parse/pull/33 is merged
+// TODO move to common when https://github.com/h0tk3y/better-parse/pull/37 is merged
 
 package space.kscience.kmath.ast
 
@@ -25,8 +25,8 @@ import space.kscience.kmath.operations.SpaceOperations
  */
 public object ArithmeticsEvaluator : Grammar<MST>() {
     // TODO replace with "...".toRegex() when better-parse 0.4.1 is released
-    private val num: Token by regexToken("[\\d.]+(?:[eE][-+]?\\d+)?")
-    private val id: Token by regexToken("[a-z_A-Z][\\da-z_A-Z]*")
+    private val num: Token by regexToken("[\\d.]+(?:[eE][-+]?\\d+)?".toRegex())
+    private val id: Token by regexToken("[a-z_A-Z][\\da-z_A-Z]*".toRegex())
     private val lpar: Token by literalToken("(")
     private val rpar: Token by literalToken(")")
     private val comma: Token by literalToken(",")
@@ -35,7 +35,7 @@ public object ArithmeticsEvaluator : Grammar<MST>() {
     private val div: Token by literalToken("/")
     private val minus: Token by literalToken("-")
     private val plus: Token by literalToken("+")
-    private val ws: Token by regexToken("\\s+", ignore = true)
+    private val ws: Token by regexToken("\\s+".toRegex(), ignore = true)
 
     private val number: Parser<MST> by num use { MST.Numeric(text.toDouble()) }
     private val singular: Parser<MST> by id use { MST.Symbolic(text) }
-- 
2.34.1


From d0cf16c8a616c338b981c6b7b38935811de1530f Mon Sep 17 00:00:00 2001
From: Iaroslav Postovalov <postovalovya@gmail.com>
Date: Sun, 28 Feb 2021 17:06:47 +0700
Subject: [PATCH 03/37] Rework GA workflows

---
 .github/workflows/build.yml   | 110 ++++++--------------------------
 .github/workflows/deploy.yml  |  43 +++++++++++++
 .github/workflows/release.yml | 117 ----------------------------------
 build.gradle.kts              |  15 ++++-
 gradle.properties             |   1 +
 5 files changed, 75 insertions(+), 211 deletions(-)
 create mode 100644 .github/workflows/deploy.yml
 delete mode 100644 .github/workflows/release.yml

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 626062abf..56f8721eb 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -1,107 +1,35 @@
-name: Gradle build
-
+name: build
 on: [ push ]
 
 jobs:
-  build-ubuntu:
-    runs-on: ubuntu-20.04
-
+  build:
+    strategy:
+      matrix:
+        os: [ macOS-latest, windows-latest ]
+    runs-on: ${{matrix.os}}
     steps:
-      - uses: actions/checkout@v2
+      - name: Checkout the repo
+        uses: actions/checkout@v2
       - name: Set up JDK 11
         uses: actions/setup-java@v1
         with:
           java-version: 11
-      - name: Grant execute permission for gradlew
-        run: chmod +x gradlew
-      - name: Install Chrome
-        run: |
-          sudo apt install -y libappindicator1 fonts-liberation
-          wget https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb
-          sudo dpkg -i google-chrome*.deb
-      - name: Cache gradle
-        uses: actions/cache@v2
-        with:
-          path: |
-            .gradle
-            build
-            ~/.gradle
-          key: gradle
-          restore-keys: gradle
-
-      - name: Cache konan
-        uses: actions/cache@v2
-        with:
-          path: |
-            ~/.konan/dependencies
-            ~/.konan/kotlin-native-prebuilt-linux-*
-          key: ${{ runner.os }}-konan
-          restore-keys: ${{ runner.os }}-konan
-      - name: Build with Gradle
-        run: ./gradlew -Dorg.gradle.daemon=false --build-cache build
-
-  build-osx:
-    runs-on: macos-latest
-
-    steps:
-      - uses: actions/checkout@v2
-      - name: Set up JDK 11
-        uses: actions/setup-java@v1
-        with:
-          java-version: 11
-      - name: Grant execute permission for gradlew
-        run: chmod +x gradlew
-      - name: Cache gradle
-        uses: actions/cache@v2
-        with:
-          path: |
-            .gradle
-            build
-            ~/.gradle
-          key: gradle
-          restore-keys: gradle
-
-      - name: Cache konan
-        uses: actions/cache@v2
-        with:
-          path: |
-            ~/.konan/dependencies
-            ~/.konan/kotlin-native-prebuilt-macos-*
-          key: ${{ runner.os }}-konan
-          restore-keys: ${{ runner.os }}-konan
-      - name: Build with Gradle
-        run: sudo ./gradlew -Dorg.gradle.daemon=false --build-cache build
-
-  build-windows:
-    runs-on: windows-latest
-
-    steps:
-      - uses: actions/checkout@v2
-      - name: Set up JDK 11
-        uses: actions/setup-java@v1
-        with:
-          java-version: 11
-      - name: Grant execute permission for gradlew
-        run: chmod +x gradlew
       - name: Add msys to path
+        if: matrix.os == 'windows-latest'
         run: SETX PATH "%PATH%;C:\msys64\mingw64\bin"
       - name: Cache gradle
         uses: actions/cache@v2
         with:
-          path: |
-            .gradle
-            build
-            ~/.gradle
-          key: ${{ runner.os }}-gradle
-          restore-keys: ${{ runner.os }}-gradle
-
+          path: ~/.gradle/caches
+          key: ${{ runner.os }}-gradle-${{ hashFiles('*.gradle.kts') }}
+          restore-keys: |
+            ${{ runner.os }}-gradle-
       - name: Cache konan
         uses: actions/cache@v2
         with:
-          path: |
-            ~/.konan/dependencies
-            ~/.konan/kotlin-native-prebuilt-mingw-*
-          key: ${{ runner.os }}-konan
-          restore-keys: ${{ runner.os }}-konan
-      - name: Build with Gradle
-        run: ./gradlew --build-cache build
+          path: ~/.konan
+          key: ${{ runner.os }}-gradle-${{ hashFiles('*.gradle.kts') }}
+          restore-keys: |
+            ${{ runner.os }}-gradle-
+      - name: Build
+        run: ./gradlew build --no-daemon --stacktrace
diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
new file mode 100644
index 000000000..83be65b50
--- /dev/null
+++ b/.github/workflows/deploy.yml
@@ -0,0 +1,43 @@
+name: deploy
+on: workflow_dispatch
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        os: [macOS-latest, windows-latest]
+    runs-on: ${{matrix.os}}
+    steps:
+      - name: Checkout the repo
+        uses: actions/checkout@v2
+      - name: Set up JDK 11
+        uses: actions/setup-java@v1
+        with:
+          java-version: 11
+      - name: Add msys to path
+        if: matrix.os == 'windows-latest'
+        run: SETX PATH "%PATH%;C:\msys64\mingw64\bin"
+      - name: Cache gradle
+        uses: actions/cache@v2
+        with:
+          path: ~/.gradle/caches
+          key: ${{ runner.os }}-gradle-${{ hashFiles('*.gradle.kts') }}
+          restore-keys: |
+            ${{ runner.os }}-gradle-
+      - name: Cache konan
+        uses: actions/cache@v2
+        with:
+          path: ~/.konan
+          key: ${{ runner.os }}-gradle-${{ hashFiles('*.gradle.kts') }}
+          restore-keys: |
+            ${{ runner.os }}-gradle-
+      - name: Publish Mac Artifacts
+        if: matrix.os == 'macOS-latest'
+        run: ./gradlew publish --no-daemon --stacktrace -PsonatypePublish=true -PsonatypeUser=${{ secrets.SONATYPE_USERNAME }} -PsonatypePassword=${{ secrets.SONATYPE_PASSWORD }}
+        env:
+          signingKey: ${{ secrets.SIGNING_KEY }}
+      - name: Publish Windows Artifacts
+        if: matrix.os == 'windows-latest'
+        run: ./gradlew publish --no-daemon --stacktrace -PsonatypePublish=true -PsonatypeUser=${{ secrets.SONATYPE_USERNAME }} -PsonatypePassword=${{ secrets.SONATYPE_PASSWORD }}
+        env:
+          signingKey: ${{ secrets.SIGNING_KEY }}
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
deleted file mode 100644
index 743520885..000000000
--- a/.github/workflows/release.yml
+++ /dev/null
@@ -1,117 +0,0 @@
-name: Gradle release
-
-on:
-  release:
-    types:
-      - created
-
-jobs:
-  build-ubuntu:
-    runs-on: ubuntu-20.04
-
-    steps:
-      - uses: actions/checkout@v2
-      - name: Set up JDK 11
-        uses: actions/setup-java@v1
-        with:
-          java-version: 11
-      - name: Grant execute permission for gradlew
-        run: chmod +x gradlew
-      - name: Install Chrome
-        run: |
-          sudo apt install -y libappindicator1 fonts-liberation
-          wget https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb
-          sudo dpkg -i google-chrome*.deb
-      - name: Cache gradle
-        uses: actions/cache@v2
-        with:
-          path: |
-            .gradle
-            build
-            ~/.gradle
-          key: gradle
-          restore-keys: gradle
-
-      - name: Cache konan
-        uses: actions/cache@v2
-        with:
-          path: |
-            ~/.konan/dependencies
-            ~/.konan/kotlin-native-prebuilt-linux-*
-          key: ${{ runner.os }}-konan
-          restore-keys: ${{ runner.os }}-konan
-      - name: Build with Gradle
-        run: ./gradlew -Dorg.gradle.daemon=false --build-cache build
-      - name: Run release task
-        run: ./gradlew release -PbintrayUser=${{ secrets.BINTRAY_USER }} -PbintrayApiKey=${{ secrets.BINTRAY_KEY }}
-
-  build-osx:
-    runs-on: macos-latest
-
-    steps:
-      - uses: actions/checkout@v2
-      - name: Set up JDK 11
-        uses: actions/setup-java@v1
-        with:
-          java-version: 11
-      - name: Grant execute permission for gradlew
-        run: chmod +x gradlew
-      - name: Cache gradle
-        uses: actions/cache@v2
-        with:
-          path: |
-            .gradle
-            build
-            ~/.gradle
-          key: gradle
-          restore-keys: gradle
-
-      - name: Cache konan
-        uses: actions/cache@v2
-        with:
-          path: |
-            ~/.konan/dependencies
-            ~/.konan/kotlin-native-prebuilt-macos-*
-          key: ${{ runner.os }}-konan
-          restore-keys: ${{ runner.os }}-konan
-      - name: Build with Gradle
-        run: sudo ./gradlew -Dorg.gradle.daemon=false --build-cache build
-      - name: Run release task
-        run: ./gradlew release -PbintrayUser=${{ secrets.BINTRAY_USER }} -PbintrayApiKey=${{ secrets.BINTRAY_KEY }}
-
-  build-windows:
-    runs-on: windows-latest
-
-    steps:
-      - uses: actions/checkout@v2
-      - name: Set up JDK 11
-        uses: actions/setup-java@v1
-        with:
-          java-version: 11
-      - name: Grant execute permission for gradlew
-        run: chmod +x gradlew
-      - name: Add msys to path
-        run: SETX PATH "%PATH%;C:\msys64\mingw64\bin"
-      - name: Cache gradle
-        uses: actions/cache@v2
-        with:
-          path: |
-            .gradle
-            build
-            ~/.gradle
-          key: ${{ runner.os }}-gradle
-          restore-keys: ${{ runner.os }}-gradle
-
-      - name: Cache konan
-        uses: actions/cache@v2
-        with:
-          path: |
-            ~/.konan/dependencies
-            ~/.konan/kotlin-native-prebuilt-mingw-*
-          key: ${{ runner.os }}-konan
-          restore-keys: ${{ runner.os }}-konan
-      - name: Build with Gradle
-        run: ./gradlew --build-cache build
-      - name: Run release task
-        run: ./gradlew release -PbintrayUser=${{ secrets.BINTRAY_USER }} -PbintrayApiKey=${{ secrets.BINTRAY_KEY }}
-
diff --git a/build.gradle.kts b/build.gradle.kts
index 83123765d..9e2b42a3c 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -1,3 +1,5 @@
+import ru.mipt.npm.gradle.KSciencePublishingPlugin
+
 plugins {
     id("ru.mipt.npm.gradle.project")
 }
@@ -22,7 +24,14 @@ allprojects {
 }
 
 subprojects {
-    if (name.startsWith("kmath")) apply<ru.mipt.npm.gradle.KSciencePublishingPlugin>()
+    if (name.startsWith("kmath")) {
+        apply<KSciencePublishingPlugin>()
+
+        val publishWindows by tasks.creating {
+            tasks.find { it.name == "publishMingwX64PublicationToSpaceRepository" }?.let { dependsOn(it) }
+            tasks.find { it.name == "publishMingwX64PublicationToSonatypeRepository" }?.let { dependsOn(it) }
+        }
+    }
 }
 
 readme {
@@ -35,6 +44,6 @@ ksciencePublish {
     githubProject = "kmath"
 }
 
-apiValidation{
+apiValidation {
     nonPublicMarkers.add("space.kscience.kmath.misc.UnstableKMathAPI")
-}
\ No newline at end of file
+}
diff --git a/gradle.properties b/gradle.properties
index 88b90f27b..1a2a263ac 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -3,6 +3,7 @@ kotlin.mpp.enableGranularSourceSetsMetadata=true
 kotlin.mpp.stability.nowarn=true
 kotlin.native.enableDependencyPropagation=false
 kotlin.parallel.tasks.in.project=true
+org.gradle.configureondemand=true
 org.gradle.jvmargs=-XX:MaxMetaspaceSize=512m
 org.gradle.parallel=true
 systemProp.org.gradle.internal.publish.checksums.insecure=true
-- 
2.34.1


From 13792b07b2eb9670654d52b44eefc739820bad90 Mon Sep 17 00:00:00 2001
From: Iaroslav Postovalov <postovalovya@gmail.com>
Date: Sun, 28 Feb 2021 17:14:41 +0700
Subject: [PATCH 04/37] Add Touchlab notice

---
 .github/workflows/build.yml  | 2 ++
 .github/workflows/deploy.yml | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 56f8721eb..3b9005997 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -1,3 +1,5 @@
+# Based on https://github.com/touchlab/Stately/blob/main/.github/workflows/build.yml
+
 name: build
 on: [ push ]
 
diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
index 83be65b50..40a703309 100644
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -1,3 +1,5 @@
+# Based on https://github.com/touchlab/Stately/blob/main/.github/workflows/deploy.yml
+
 name: deploy
 on: workflow_dispatch
 
-- 
2.34.1


From a68b102e401ab7524de30130f11487ca931c3151 Mon Sep 17 00:00:00 2001
From: Iaroslav Postovalov <postovalovya@gmail.com>
Date: Sun, 28 Feb 2021 20:23:02 +0700
Subject: [PATCH 05/37] Update deploy.yml

---
 .github/workflows/deploy.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
index 40a703309..9fcdec036 100644
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -35,11 +35,11 @@ jobs:
             ${{ runner.os }}-gradle-
       - name: Publish Mac Artifacts
         if: matrix.os == 'macOS-latest'
-        run: ./gradlew publish --no-daemon --stacktrace -PsonatypePublish=true -PsonatypeUser=${{ secrets.SONATYPE_USERNAME }} -PsonatypePassword=${{ secrets.SONATYPE_PASSWORD }}
+        run: ./gradlew publishAllPublicationsToSpaceRepository publishAllPublicationsToSonatypeRepository --no-daemon --stacktrace -PsonatypePublish=true -PsonatypeUser=${{ secrets.SONATYPE_USERNAME }} -PsonatypePassword=${{ secrets.SONATYPE_PASSWORD }}
         env:
           signingKey: ${{ secrets.SIGNING_KEY }}
       - name: Publish Windows Artifacts
         if: matrix.os == 'windows-latest'
-        run: ./gradlew publish --no-daemon --stacktrace -PsonatypePublish=true -PsonatypeUser=${{ secrets.SONATYPE_USERNAME }} -PsonatypePassword=${{ secrets.SONATYPE_PASSWORD }}
+        run: ./gradlew publishMingwX64PublicationToSpaceRepository publishMingwX64PublicationToSonatypeRepository --no-daemon --stacktrace -PsonatypePublish=true -PsonatypeUser=${{ secrets.SONATYPE_USERNAME }} -PsonatypePassword=${{ secrets.SONATYPE_PASSWORD }}
         env:
           signingKey: ${{ secrets.SIGNING_KEY }}
-- 
2.34.1


From 4ec33c6857f164ae58dc5408eb4180b7b26dbcd1 Mon Sep 17 00:00:00 2001
From: Iaroslav Postovalov <postovalovya@gmail.com>
Date: Sun, 28 Feb 2021 20:23:16 +0700
Subject: [PATCH 06/37] Remove publishWindows task

---
 build.gradle.kts | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

diff --git a/build.gradle.kts b/build.gradle.kts
index 9e2b42a3c..cb3cb1a3b 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -24,14 +24,7 @@ allprojects {
 }
 
 subprojects {
-    if (name.startsWith("kmath")) {
-        apply<KSciencePublishingPlugin>()
-
-        val publishWindows by tasks.creating {
-            tasks.find { it.name == "publishMingwX64PublicationToSpaceRepository" }?.let { dependsOn(it) }
-            tasks.find { it.name == "publishMingwX64PublicationToSonatypeRepository" }?.let { dependsOn(it) }
-        }
-    }
+    if (name.startsWith("kmath")) apply<KSciencePublishingPlugin>()
 }
 
 readme {
-- 
2.34.1


From 30bd56d0f71261d20533d8720500be6faf96d265 Mon Sep 17 00:00:00 2001
From: Iaroslav Postovalov <postovalovya@gmail.com>
Date: Sun, 28 Feb 2021 21:29:21 +0700
Subject: [PATCH 07/37] Support space credentials

---
 .github/workflows/deploy.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
index 9fcdec036..997755816 100644
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -35,11 +35,11 @@ jobs:
             ${{ runner.os }}-gradle-
       - name: Publish Mac Artifacts
         if: matrix.os == 'macOS-latest'
-        run: ./gradlew publishAllPublicationsToSpaceRepository publishAllPublicationsToSonatypeRepository --no-daemon --stacktrace -PsonatypePublish=true -PsonatypeUser=${{ secrets.SONATYPE_USERNAME }} -PsonatypePassword=${{ secrets.SONATYPE_PASSWORD }}
+        run: ./gradlew publishAllPublicationsToSpaceRepository publishAllPublicationsToSonatypeRepository --no-daemon --stacktrace -PsonatypePublish=true -PsonatypeUser=${{ secrets.SONATYPE_USERNAME }} -PsonatypePassword=${{ secrets.SONATYPE_PASSWORD }} -PspaceUser=${{ secrets.SPACE_USERNAME }} -PspacePassword=${{ secrets.SPACE_PASSWORD }}
         env:
           signingKey: ${{ secrets.SIGNING_KEY }}
       - name: Publish Windows Artifacts
         if: matrix.os == 'windows-latest'
-        run: ./gradlew publishMingwX64PublicationToSpaceRepository publishMingwX64PublicationToSonatypeRepository --no-daemon --stacktrace -PsonatypePublish=true -PsonatypeUser=${{ secrets.SONATYPE_USERNAME }} -PsonatypePassword=${{ secrets.SONATYPE_PASSWORD }}
+        run: ./gradlew publishAllPublicationsToSpaceRepository publishAllPublicationsToSonatypeRepository --no-daemon --stacktrace -PsonatypePublish=true -PsonatypeUser=${{ secrets.SONATYPE_USERNAME }} -PsonatypePassword=${{ secrets.SONATYPE_PASSWORD }} -PspaceUser=${{ secrets.SPACE_USERNAME }} -PspacePassword=${{ secrets.SPACE_PASSWORD }}
         env:
           signingKey: ${{ secrets.SIGNING_KEY }}
-- 
2.34.1


From 477f7dd0799c67882f67742b30feb004a658f9f7 Mon Sep 17 00:00:00 2001
From: Roland Grinis <roland.grinis@grinisrit.com>
Date: Mon, 1 Mar 2021 13:01:15 +0000
Subject: [PATCH 08/37] Deprecating div methods

---
 .../kscience/kmath/operations/Algebra.kt      |   1 +
 .../kscience/kmath/nd4j/Nd4jArrayAlgebra.kt   |   1 +
 .../src/cppMain/.vscode/c_cpp_properties.json |  21 ++++++
 kmath-torch/src/cppMain/.vscode/settings.json |  71 ++++++++++++++++++
 .../java/kscience/kmath/torch/JTorch.class    | Bin 0 -> 3022 bytes
 5 files changed, 94 insertions(+)
 create mode 100644 kmath-torch/src/cppMain/.vscode/c_cpp_properties.json
 create mode 100644 kmath-torch/src/cppMain/.vscode/settings.json
 create mode 100644 kmath-torch/src/jvmMain/java/kscience/kmath/torch/JTorch.class

diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/Algebra.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/Algebra.kt
index 201e39314..572f7089a 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/Algebra.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/Algebra.kt
@@ -175,6 +175,7 @@ public interface SpaceOperations<T> : Algebra<T> {
      * @param k the divisor.
      * @return the quotient.
      */
+    @Deprecated("Dividing not allowed in a Ring")
     public operator fun T.div(k: Number): T = multiply(this, 1.0 / k.toDouble())
 
     /**
diff --git a/kmath-nd4j/src/main/kotlin/space/kscience/kmath/nd4j/Nd4jArrayAlgebra.kt b/kmath-nd4j/src/main/kotlin/space/kscience/kmath/nd4j/Nd4jArrayAlgebra.kt
index 1e9818a4a..c50174b95 100644
--- a/kmath-nd4j/src/main/kotlin/space/kscience/kmath/nd4j/Nd4jArrayAlgebra.kt
+++ b/kmath-nd4j/src/main/kotlin/space/kscience/kmath/nd4j/Nd4jArrayAlgebra.kt
@@ -96,6 +96,7 @@ public interface Nd4jArraySpace<T, S : Space<T>> : NDSpace<T, S>, Nd4jArrayAlgeb
         return a.ndArray.mul(k).wrap()
     }
 
+    @Deprecated("Avoid using this method, underlying array get casted to Doubles")
     public override operator fun NDStructure<T>.div(k: Number): Nd4jArrayStructure<T> {
         return ndArray.div(k).wrap()
     }
diff --git a/kmath-torch/src/cppMain/.vscode/c_cpp_properties.json b/kmath-torch/src/cppMain/.vscode/c_cpp_properties.json
new file mode 100644
index 000000000..711f47bff
--- /dev/null
+++ b/kmath-torch/src/cppMain/.vscode/c_cpp_properties.json
@@ -0,0 +1,21 @@
+{
+    "configurations": [
+        {
+            "name": "Linux",
+            "includePath": [
+                "${workspaceFolder}/**",
+                "${env:HOME}/miniconda3/envs/ghmc/include", 
+                "${env:HOME}/miniconda3/envs/ghmc/include/python3.8", 
+                "${env:HOME}/miniconda3/envs/ghmc/include/torch/csrc/api/include",
+                "${env:HOME}/.jdks/openjdk-15.0.2/include",
+                "${env:HOME}/.jdks/openjdk-15.0.2/include/linux"
+            ],
+            "defines": [],
+            "compilerPath": "/usr/bin/gcc",
+            "cStandard": "gnu11",
+            "cppStandard": "gnu++17",
+            "intelliSenseMode": "gcc-x64"
+        }
+    ],
+    "version": 4
+}
\ No newline at end of file
diff --git a/kmath-torch/src/cppMain/.vscode/settings.json b/kmath-torch/src/cppMain/.vscode/settings.json
new file mode 100644
index 000000000..fd26c7488
--- /dev/null
+++ b/kmath-torch/src/cppMain/.vscode/settings.json
@@ -0,0 +1,71 @@
+{
+    "python.linting.pylintEnabled": false,
+    "python.linting.mypyEnabled": true,
+    "python.linting.enabled": false,
+    "files.associations": {
+        "chrono": "cpp",
+        "cctype": "cpp",
+        "clocale": "cpp",
+        "cmath": "cpp",
+        "cstdarg": "cpp",
+        "cstddef": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "cstring": "cpp",
+        "ctime": "cpp",
+        "cwchar": "cpp",
+        "cwctype": "cpp",
+        "array": "cpp",
+        "atomic": "cpp",
+        "*.tcc": "cpp",
+        "cinttypes": "cpp",
+        "complex": "cpp",
+        "condition_variable": "cpp",
+        "cstdint": "cpp",
+        "deque": "cpp",
+        "forward_list": "cpp",
+        "list": "cpp",
+        "unordered_map": "cpp",
+        "unordered_set": "cpp",
+        "vector": "cpp",
+        "exception": "cpp",
+        "algorithm": "cpp",
+        "functional": "cpp",
+        "iterator": "cpp",
+        "map": "cpp",
+        "memory": "cpp",
+        "memory_resource": "cpp",
+        "numeric": "cpp",
+        "optional": "cpp",
+        "random": "cpp",
+        "ratio": "cpp",
+        "set": "cpp",
+        "string": "cpp",
+        "string_view": "cpp",
+        "system_error": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "utility": "cpp",
+        "fstream": "cpp",
+        "initializer_list": "cpp",
+        "iomanip": "cpp",
+        "iosfwd": "cpp",
+        "iostream": "cpp",
+        "istream": "cpp",
+        "limits": "cpp",
+        "mutex": "cpp",
+        "new": "cpp",
+        "ostream": "cpp",
+        "sstream": "cpp",
+        "stdexcept": "cpp",
+        "streambuf": "cpp",
+        "thread": "cpp",
+        "typeindex": "cpp",
+        "typeinfo": "cpp",
+        "valarray": "cpp",
+        "variant": "cpp",
+        "future": "cpp",
+        "bit": "cpp"
+    },
+    "python.pythonPath": "${env:HOME}/miniconda3/envs/ghmc/bin/python"
+}
\ No newline at end of file
diff --git a/kmath-torch/src/jvmMain/java/kscience/kmath/torch/JTorch.class b/kmath-torch/src/jvmMain/java/kscience/kmath/torch/JTorch.class
new file mode 100644
index 0000000000000000000000000000000000000000..d3ce6fcc9b61d2acc35c9bd9c5d5978314a56454
GIT binary patch
literal 3022
zcmZWrXL}n(5T1*za*{0B0n<VWp`8On^kx%qq9{l>3E0MfO*=_z>1^pvxjV@*z4zXG
z@89?Y4<Gme{3sq~W@pbf<awNT=bfE*XJ&VA_4hx2{sjQj@M{is!AJ&13y^}e1><Y(
z&@Fdezg<4jSX0f|g7l2%d+|XFMx3doEM$>ci-WM)$w3bC87LHB42nBK7dE3<^(@GD
z1GhEjH9|Msv|!Si+frYML(gwdPc3C&+=4ypQPWd?Q<c|yZrmxee!0F#%UCdaIA|#g
zN^_pCjt_bb6)w7sE;3_n6(h0O36<N5IKvvU(N1>MsZA|mcyrKlYtih`^}0G73tF}y
zgVPt3YGJyn*N-<Bl^+Emi`6YCu7*MHP&a5)f&s6Ybyg}Xwb~T=#*D9ubz-N`RTWpk
zxaI=C&7Qh=^2Ss1bx2Jdxn|H$79Vx$v_gToprVFe6YEVmbza!el2TsJk}R}Npcl5a
zi`U9W8*X1$hrL3rI<+M?^wfr_IqhJYv~V%zE-VImpJ?;yQ~%#S>_N+m`az_O0ws>B
zY22BLhev>H+>@-{Db>XVak$WN`)U^J=ZesuClZfDi&>kZrDodW8lEQ8e-f-<XM~ob
ziLGiGnyibbmB`}iSyLLO%S07QOB6JR8X4qtJQcyQ+J|Y{cvegz8R}Jqip?S`Doj?1
zq+_LJnA2TBjs=<GQ<)20zhxxTjyWX6`i8d2GP}zjF~-R7{3N9;?x{I|;*yzpF{LqL
zaV}Xh=Dc-0Uqv&VjUun@W4%Q9+F44*#+!(8Fg6KK6rP<4nuu9Zn3<}bblg@4-L5Gt
z<Cv>t6P@(X+@dV8+nUHnGee|w(cGPU?DbS+WK&Ls6Ui|vswt<+q|Kxj<vV~GXPINo
zlvC41Y*REvurAgxzNNe6LUnYN5_RJ#8f`=H3e<^ycaWrPlOdUAX)IOKkn<Yfnr(zi
zNsM8NCejdN5^rqXCv#UPI5lmV8FtGX8h<Gn8!zW<+?>+R=zP!f2a%aDvCT>p20lIp
z$7mWJFSn6QE+u0#wG`t)+VOG0Q>4GVlmBs<5Iq5#YpYZ8slz=<#%7w`4caEjQZi1w
z5k4vM2$Yhs@uu;C>J9KaR?q{(PiS-AYj<M9VKd$K5qz-laltEJ)5+V>ux0d-rCWm;
z7oyFc@{+XJvCNK8og8?fijIaZ>d==CU#${;O6GSs@G$fIQcJ~dvs1-)3nTjYeiq$9
z9JDdotV*|WnLqR7>8L2#h3rhTE6;syAsB>BRrTnl&Fi=L06pNa7fSf6f&Q)HAO3Ct
zy!1Fa578oK|L<V^h64+B<NxFa7_n?P4NgbWhDkVs@k}_2@ocfrfjw-Wi&8Z2e7Jyd
zFI>pD4=!T77%pMF6fR?Q#GVq|FL=4&6>ufbI{;<ItKe$JYv5YO>)?9E8w78Jo7lct
z@D|~xVTSoz;UME}qJO*iXW<a@hoQoFMAoaqQMT`Z8e<*qWSoOzjK|>w<6Uq!<GkR4
z;G*C?u*Cj*1@9BQUvOFSS&_OP5c@%~AA*ND{t<8)8_;BIfnr>RHe&}o#x+=H>_U&x
zhk&sUCmBPC7-JYP4yDf<aEk3siGNh$ACvgUCH@JCe^TO~lK7`3{u!D7tnkl?{k+&O
zi2b72FNyuK*sn<auL`~<eRv(-;QZc%w;10R|2yJ;SM2x1eqZbl#Qsp$`AF9JSnw10
zl=VJ?&l$gfFB!jruNl9AZyCQ6z3<@%wtpl&$ih#_RocgQ2Jg=9%pYKH-6i_DPB$tA
N8JzJmj(5Q?{{mD*uC)LF

literal 0
HcmV?d00001

-- 
2.34.1


From 80f21a2751740088b67567a7373615df07a7e97c Mon Sep 17 00:00:00 2001
From: Roland Grinis <roland.grinis@grinisrit.com>
Date: Mon, 1 Mar 2021 15:03:10 +0000
Subject: [PATCH 09/37] Adding .vscode to .gitignore

---
 .gitignore                                    |   1 +
 .../src/cppMain/.vscode/c_cpp_properties.json |  21 ------
 kmath-torch/src/cppMain/.vscode/settings.json |  71 ------------------
 .../java/kscience/kmath/torch/JTorch.class    | Bin 3022 -> 0 bytes
 4 files changed, 1 insertion(+), 92 deletions(-)
 delete mode 100644 kmath-torch/src/cppMain/.vscode/c_cpp_properties.json
 delete mode 100644 kmath-torch/src/cppMain/.vscode/settings.json
 delete mode 100644 kmath-torch/src/jvmMain/java/kscience/kmath/torch/JTorch.class

diff --git a/.gitignore b/.gitignore
index bade7f08c..ea8e65fb4 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,6 +2,7 @@
 build/
 out/
 .idea/
+.vscode/
 
 # Avoid ignoring Gradle wrapper jar file (.jar files are usually ignored)
 !gradle-wrapper.jar
diff --git a/kmath-torch/src/cppMain/.vscode/c_cpp_properties.json b/kmath-torch/src/cppMain/.vscode/c_cpp_properties.json
deleted file mode 100644
index 711f47bff..000000000
--- a/kmath-torch/src/cppMain/.vscode/c_cpp_properties.json
+++ /dev/null
@@ -1,21 +0,0 @@
-{
-    "configurations": [
-        {
-            "name": "Linux",
-            "includePath": [
-                "${workspaceFolder}/**",
-                "${env:HOME}/miniconda3/envs/ghmc/include", 
-                "${env:HOME}/miniconda3/envs/ghmc/include/python3.8", 
-                "${env:HOME}/miniconda3/envs/ghmc/include/torch/csrc/api/include",
-                "${env:HOME}/.jdks/openjdk-15.0.2/include",
-                "${env:HOME}/.jdks/openjdk-15.0.2/include/linux"
-            ],
-            "defines": [],
-            "compilerPath": "/usr/bin/gcc",
-            "cStandard": "gnu11",
-            "cppStandard": "gnu++17",
-            "intelliSenseMode": "gcc-x64"
-        }
-    ],
-    "version": 4
-}
\ No newline at end of file
diff --git a/kmath-torch/src/cppMain/.vscode/settings.json b/kmath-torch/src/cppMain/.vscode/settings.json
deleted file mode 100644
index fd26c7488..000000000
--- a/kmath-torch/src/cppMain/.vscode/settings.json
+++ /dev/null
@@ -1,71 +0,0 @@
-{
-    "python.linting.pylintEnabled": false,
-    "python.linting.mypyEnabled": true,
-    "python.linting.enabled": false,
-    "files.associations": {
-        "chrono": "cpp",
-        "cctype": "cpp",
-        "clocale": "cpp",
-        "cmath": "cpp",
-        "cstdarg": "cpp",
-        "cstddef": "cpp",
-        "cstdio": "cpp",
-        "cstdlib": "cpp",
-        "cstring": "cpp",
-        "ctime": "cpp",
-        "cwchar": "cpp",
-        "cwctype": "cpp",
-        "array": "cpp",
-        "atomic": "cpp",
-        "*.tcc": "cpp",
-        "cinttypes": "cpp",
-        "complex": "cpp",
-        "condition_variable": "cpp",
-        "cstdint": "cpp",
-        "deque": "cpp",
-        "forward_list": "cpp",
-        "list": "cpp",
-        "unordered_map": "cpp",
-        "unordered_set": "cpp",
-        "vector": "cpp",
-        "exception": "cpp",
-        "algorithm": "cpp",
-        "functional": "cpp",
-        "iterator": "cpp",
-        "map": "cpp",
-        "memory": "cpp",
-        "memory_resource": "cpp",
-        "numeric": "cpp",
-        "optional": "cpp",
-        "random": "cpp",
-        "ratio": "cpp",
-        "set": "cpp",
-        "string": "cpp",
-        "string_view": "cpp",
-        "system_error": "cpp",
-        "tuple": "cpp",
-        "type_traits": "cpp",
-        "utility": "cpp",
-        "fstream": "cpp",
-        "initializer_list": "cpp",
-        "iomanip": "cpp",
-        "iosfwd": "cpp",
-        "iostream": "cpp",
-        "istream": "cpp",
-        "limits": "cpp",
-        "mutex": "cpp",
-        "new": "cpp",
-        "ostream": "cpp",
-        "sstream": "cpp",
-        "stdexcept": "cpp",
-        "streambuf": "cpp",
-        "thread": "cpp",
-        "typeindex": "cpp",
-        "typeinfo": "cpp",
-        "valarray": "cpp",
-        "variant": "cpp",
-        "future": "cpp",
-        "bit": "cpp"
-    },
-    "python.pythonPath": "${env:HOME}/miniconda3/envs/ghmc/bin/python"
-}
\ No newline at end of file
diff --git a/kmath-torch/src/jvmMain/java/kscience/kmath/torch/JTorch.class b/kmath-torch/src/jvmMain/java/kscience/kmath/torch/JTorch.class
deleted file mode 100644
index d3ce6fcc9b61d2acc35c9bd9c5d5978314a56454..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 3022
zcmZWrXL}n(5T1*za*{0B0n<VWp`8On^kx%qq9{l>3E0MfO*=_z>1^pvxjV@*z4zXG
z@89?Y4<Gme{3sq~W@pbf<awNT=bfE*XJ&VA_4hx2{sjQj@M{is!AJ&13y^}e1><Y(
z&@Fdezg<4jSX0f|g7l2%d+|XFMx3doEM$>ci-WM)$w3bC87LHB42nBK7dE3<^(@GD
z1GhEjH9|Msv|!Si+frYML(gwdPc3C&+=4ypQPWd?Q<c|yZrmxee!0F#%UCdaIA|#g
zN^_pCjt_bb6)w7sE;3_n6(h0O36<N5IKvvU(N1>MsZA|mcyrKlYtih`^}0G73tF}y
zgVPt3YGJyn*N-<Bl^+Emi`6YCu7*MHP&a5)f&s6Ybyg}Xwb~T=#*D9ubz-N`RTWpk
zxaI=C&7Qh=^2Ss1bx2Jdxn|H$79Vx$v_gToprVFe6YEVmbza!el2TsJk}R}Npcl5a
zi`U9W8*X1$hrL3rI<+M?^wfr_IqhJYv~V%zE-VImpJ?;yQ~%#S>_N+m`az_O0ws>B
zY22BLhev>H+>@-{Db>XVak$WN`)U^J=ZesuClZfDi&>kZrDodW8lEQ8e-f-<XM~ob
ziLGiGnyibbmB`}iSyLLO%S07QOB6JR8X4qtJQcyQ+J|Y{cvegz8R}Jqip?S`Doj?1
zq+_LJnA2TBjs=<GQ<)20zhxxTjyWX6`i8d2GP}zjF~-R7{3N9;?x{I|;*yzpF{LqL
zaV}Xh=Dc-0Uqv&VjUun@W4%Q9+F44*#+!(8Fg6KK6rP<4nuu9Zn3<}bblg@4-L5Gt
z<Cv>t6P@(X+@dV8+nUHnGee|w(cGPU?DbS+WK&Ls6Ui|vswt<+q|Kxj<vV~GXPINo
zlvC41Y*REvurAgxzNNe6LUnYN5_RJ#8f`=H3e<^ycaWrPlOdUAX)IOKkn<Yfnr(zi
zNsM8NCejdN5^rqXCv#UPI5lmV8FtGX8h<Gn8!zW<+?>+R=zP!f2a%aDvCT>p20lIp
z$7mWJFSn6QE+u0#wG`t)+VOG0Q>4GVlmBs<5Iq5#YpYZ8slz=<#%7w`4caEjQZi1w
z5k4vM2$Yhs@uu;C>J9KaR?q{(PiS-AYj<M9VKd$K5qz-laltEJ)5+V>ux0d-rCWm;
z7oyFc@{+XJvCNK8og8?fijIaZ>d==CU#${;O6GSs@G$fIQcJ~dvs1-)3nTjYeiq$9
z9JDdotV*|WnLqR7>8L2#h3rhTE6;syAsB>BRrTnl&Fi=L06pNa7fSf6f&Q)HAO3Ct
zy!1Fa578oK|L<V^h64+B<NxFa7_n?P4NgbWhDkVs@k}_2@ocfrfjw-Wi&8Z2e7Jyd
zFI>pD4=!T77%pMF6fR?Q#GVq|FL=4&6>ufbI{;<ItKe$JYv5YO>)?9E8w78Jo7lct
z@D|~xVTSoz;UME}qJO*iXW<a@hoQoFMAoaqQMT`Z8e<*qWSoOzjK|>w<6Uq!<GkR4
z;G*C?u*Cj*1@9BQUvOFSS&_OP5c@%~AA*ND{t<8)8_;BIfnr>RHe&}o#x+=H>_U&x
zhk&sUCmBPC7-JYP4yDf<aEk3siGNh$ACvgUCH@JCe^TO~lK7`3{u!D7tnkl?{k+&O
zi2b72FNyuK*sn<auL`~<eRv(-;QZc%w;10R|2yJ;SM2x1eqZbl#Qsp$`AF9JSnw10
zl=VJ?&l$gfFB!jruNl9AZyCQ6z3<@%wtpl&$ih#_RocgQ2Jg=9%pYKH-6i_DPB$tA
N8JzJmj(5Q?{{mD*uC)LF

-- 
2.34.1


From ec4b97289686de2e0b9de58fd8372f29f8339a9d Mon Sep 17 00:00:00 2001
From: Roland Grinis <roland.grinis@grinisrit.com>
Date: Mon, 1 Mar 2021 15:15:19 +0000
Subject: [PATCH 10/37] JNI generated files added to .gitignore

---
 .gitignore | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/.gitignore b/.gitignore
index ea8e65fb4..07589aa00 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,3 +9,7 @@ out/
 
 # Cache of project
 .gradletasknamecache
+
+# Generated by javac -h and runtime
+*.class
+*.log
-- 
2.34.1


From 8ae8ebe871c8ece0964f98b7062fbe1b10278d1f Mon Sep 17 00:00:00 2001
From: Alexander Nozik <altavir@gmail.com>
Date: Mon, 8 Mar 2021 21:03:48 +0300
Subject: [PATCH 11/37] Fully refactor algebra split ScaleOperations from
 Space.

---
 .github/workflows/build.yml                   |   3 +-
 .github/workflows/{deploy.yml => publish.yml} |  38 +-
 CHANGELOG.md                                  |   5 +
 build.gradle.kts                              |   7 +-
 .../space/kscience/kmath/ast/expressions.kt   |   4 +-
 .../kmath/structures/ParallelRealNDField.kt   |  38 +-
 gradle.properties                             |   7 +-
 gradle/wrapper/gradle-wrapper.properties      |   2 +-
 .../space/kscience/kmath/ast/MstAlgebra.kt    |  58 ++-
 .../TestESTreeConsistencyWithInterpreter.kt   |  24 +-
 .../asm/TestAsmConsistencyWithInterpreter.kt  |  24 +-
 .../DerivativeStructureExpression.kt          |  13 +-
 .../kscience/kmath/commons/linear/CMMatrix.kt |   4 +-
 .../space/kscience/kmath/complex/Complex.kt   |  28 +-
 .../kscience/kmath/complex/ComplexNDField.kt  |  35 +-
 .../kscience/kmath/complex/Quaternion.kt      |  20 +-
 .../complex/ExpressionFieldForComplexTest.kt  |   6 +-
 kmath-core/README.md                          |  55 --
 kmath-core/api/kmath-core.api                 | 480 +++++-------------
 .../kmath/domains/HyperSquareDomain.kt        |  19 +-
 .../kscience/kmath/domains/RealDomain.kt      |  30 +-
 .../kmath/domains/UnconstrainedDomain.kt      |  12 +-
 .../kmath/domains/UnivariateDomain.kt         |  31 +-
 .../FunctionalExpressionAlgebra.kt            |  35 +-
 .../kmath/expressions/SimpleAutoDiff.kt       | 127 ++---
 .../kscience/kmath/linear/BufferMatrix.kt     |  12 +-
 .../kscience/kmath/linear/MatrixContext.kt    |  11 +-
 .../kmath/linear/RealMatrixContext.kt         |  18 +-
 .../kscience/kmath/linear/VectorSpace.kt      |  35 +-
 .../kscience/kmath/nd/BufferNDAlgebra.kt      |  27 +-
 .../space/kscience/kmath/nd/NDAlgebra.kt      |  32 +-
 .../space/kscience/kmath/nd/RealNDField.kt    |   8 +-
 .../space/kscience/kmath/nd/ShortNDRing.kt    |   4 +-
 .../kscience/kmath/operations/Algebra.kt      |  57 +--
 .../kmath/operations/AlgebraElements.kt       |  51 +-
 .../space/kscience/kmath/operations/BigInt.kt |  17 +-
 .../kmath/operations/NumericAlgebra.kt        |  45 +-
 .../kmath/operations/OptionalOperations.kt    | 202 ++++----
 .../kmath/operations/algebraExtensions.kt     |  12 +-
 .../kscience/kmath/operations/numbers.kt      |  65 +--
 .../kmath/structures/RealBufferField.kt       |  45 +-
 .../kmath/expressions/ExpressionFieldTest.kt  |   4 +-
 .../kscience/kmath/testutils/FieldVerifier.kt |   5 +-
 .../kscience/kmath/testutils/RingVerifier.kt  |   6 +-
 .../kscience/kmath/testutils/SpaceVerifier.kt |  10 +-
 .../kscience/kmath/operations/BigNumbers.kt   |  17 +-
 .../space/kscience/kmath/chains/flowExtra.kt  |   4 +-
 .../kscience/kmath/ejml/EjmlMatrixContext.kt  |  10 +-
 .../kscience/kmath/functions/Polynomial.kt    |  15 +-
 .../kmath/interpolation/SplineInterpolator.kt |   6 +-
 .../kmath/geometry/Euclidean2DSpace.kt        |   9 +-
 .../kmath/geometry/Euclidean3DSpace.kt        |  10 +-
 .../kmath/histogram/IndexedHistogramSpace.kt  |  14 +-
 .../kmath/histogram/RealHistogramSpace.kt     |   4 +
 .../kmath/histogram/TreeHistogramSpace.kt     |  11 +-
 .../kmath/histogram/UnivariateHistogram.kt    |   2 +
 .../kscience/kmath/nd4j/Nd4jArrayAlgebra.kt   |  27 +-
 .../kscience/kmath/stat/SamplerAlgebra.kt     |  15 +-
 .../space/kscience/kmath/stat/Statistic.kt    |  20 +-
 kmath-viktor/api/kmath-viktor.api             |  11 +-
 .../kmath/viktor/ViktorNDStructure.kt         |  12 +-
 settings.gradle.kts                           |   7 +-
 62 files changed, 869 insertions(+), 1096 deletions(-)
 rename .github/workflows/{deploy.yml => publish.yml} (52%)
 delete mode 100644 kmath-core/README.md

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 3b9005997..25f2cfd0d 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -1,6 +1,5 @@
-# Based on https://github.com/touchlab/Stately/blob/main/.github/workflows/build.yml
+name: Gradle build
 
-name: build
 on: [ push ]
 
 jobs:
diff --git a/.github/workflows/deploy.yml b/.github/workflows/publish.yml
similarity index 52%
rename from .github/workflows/deploy.yml
rename to .github/workflows/publish.yml
index 997755816..42fa6d3b6 100644
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/publish.yml
@@ -1,10 +1,15 @@
-# Based on https://github.com/touchlab/Stately/blob/main/.github/workflows/deploy.yml
+name: Gradle publish
 
-name: deploy
-on: workflow_dispatch
+on:
+  workflow_dispatch:
+  release:
+    types:
+      - created
 
 jobs:
-  build:
+  publish:
+    environment:
+      name: publish
     strategy:
       matrix:
         os: [macOS-latest, windows-latest]
@@ -33,13 +38,22 @@ jobs:
           key: ${{ runner.os }}-gradle-${{ hashFiles('*.gradle.kts') }}
           restore-keys: |
             ${{ runner.os }}-gradle-
-      - name: Publish Mac Artifacts
-        if: matrix.os == 'macOS-latest'
-        run: ./gradlew publishAllPublicationsToSpaceRepository publishAllPublicationsToSonatypeRepository --no-daemon --stacktrace -PsonatypePublish=true -PsonatypeUser=${{ secrets.SONATYPE_USERNAME }} -PsonatypePassword=${{ secrets.SONATYPE_PASSWORD }} -PspaceUser=${{ secrets.SPACE_USERNAME }} -PspacePassword=${{ secrets.SPACE_PASSWORD }}
-        env:
-          signingKey: ${{ secrets.SIGNING_KEY }}
       - name: Publish Windows Artifacts
         if: matrix.os == 'windows-latest'
-        run: ./gradlew publishAllPublicationsToSpaceRepository publishAllPublicationsToSonatypeRepository --no-daemon --stacktrace -PsonatypePublish=true -PsonatypeUser=${{ secrets.SONATYPE_USERNAME }} -PsonatypePassword=${{ secrets.SONATYPE_PASSWORD }} -PspaceUser=${{ secrets.SPACE_USERNAME }} -PspacePassword=${{ secrets.SPACE_PASSWORD }}
-        env:
-          signingKey: ${{ secrets.SIGNING_KEY }}
+        run: >
+          ./gradlew release --no-daemon
+          -Ppublishing.enabled=true
+          -Ppublishing.github.user=${{ secrets.PUBLISHING_GITHUB_USER }}
+          -Ppublishing.github.token=${{ secrets.PUBLISHING_GITHUB_TOKEN }}
+          -Ppublishing.space.user=${{ secrets.PUBLISHING_SPACE_USER }}
+          -Ppublishing.space.token=${{ secrets.PUBLISHING_SPACE_TOKEN }}
+      - name: Publish Mac Artifacts
+        if: matrix.os == 'macOS-latest'
+        run: >
+          ./gradlew release --no-daemon
+          -Ppublishing.enabled=true
+          -Ppublishing.platform=macosX64
+          -Ppublishing.github.user=${{ secrets.PUBLISHING_GITHUB_USER }}
+          -Ppublishing.github.token=${{ secrets.PUBLISHING_GITHUB_TOKEN }}
+          -Ppublishing.space.user=${{ secrets.PUBLISHING_SPACE_USER }}
+          -Ppublishing.space.token=${{ secrets.PUBLISHING_SPACE_TOKEN }}
diff --git a/CHANGELOG.md b/CHANGELOG.md
index c7033df7f..db3b65024 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,12 +2,17 @@
 
 ## [Unreleased]
 ### Added
+- Intrinsic value `two` for ExtendedField to work with hyperbolic functions
+- ScaleOperations interface
 
 ### Changed
+- Exponential operations merged with hyperbolic functions
 
 ### Deprecated
 
 ### Removed
+- Nearest in Domain. To be implemented in geometry package.
+- Number multiplication and division in main Algebra chain
 
 ### Fixed
 
diff --git a/build.gradle.kts b/build.gradle.kts
index cb3cb1a3b..41e8a3468 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -20,7 +20,7 @@ allprojects {
     }
 
     group = "space.kscience"
-    version = "0.2.0"
+    version = "0.3.0"
 }
 
 subprojects {
@@ -32,9 +32,8 @@ readme {
 }
 
 ksciencePublish {
-    spaceRepo = "https://maven.pkg.jetbrains.space/mipt-npm/p/sci/maven"
-    bintrayRepo = "kscience"
-    githubProject = "kmath"
+    github("kmath")
+    space()
 }
 
 apiValidation {
diff --git a/examples/src/main/kotlin/space/kscience/kmath/ast/expressions.kt b/examples/src/main/kotlin/space/kscience/kmath/ast/expressions.kt
index ee0f4a492..8d6851ef8 100644
--- a/examples/src/main/kotlin/space/kscience/kmath/ast/expressions.kt
+++ b/examples/src/main/kotlin/space/kscience/kmath/ast/expressions.kt
@@ -6,10 +6,10 @@ import space.kscience.kmath.operations.RealField
 fun main() {
     val expr = RealField.mstInField {
         val x = bindSymbol("x")
-        x * 2.0 + 2.0 / x - 16.0
+        x * 2.0 + 2.0 * one / x - 16.0
     }
 
-    repeat(10000000){
+    repeat(10000000) {
         expr.invoke("x" to 1.0)
     }
 }
\ No newline at end of file
diff --git a/examples/src/main/kotlin/space/kscience/kmath/structures/ParallelRealNDField.kt b/examples/src/main/kotlin/space/kscience/kmath/structures/ParallelRealNDField.kt
index 111cfec80..0c914468d 100644
--- a/examples/src/main/kotlin/space/kscience/kmath/structures/ParallelRealNDField.kt
+++ b/examples/src/main/kotlin/space/kscience/kmath/structures/ParallelRealNDField.kt
@@ -3,8 +3,8 @@ package space.kscience.kmath.structures
 import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.nd.*
 import space.kscience.kmath.operations.ExtendedField
+import space.kscience.kmath.operations.NumbersAddOperations
 import space.kscience.kmath.operations.RealField
-import space.kscience.kmath.operations.RingWithNumbers
 import java.util.*
 import java.util.stream.IntStream
 
@@ -15,7 +15,7 @@ import java.util.stream.IntStream
 class StreamRealNDField(
     override val shape: IntArray,
 ) : NDField<Double, RealField>,
-    RingWithNumbers<NDStructure<Double>>,
+    NumbersAddOperations<NDStructure<Double>>,
     ExtendedField<NDStructure<Double>> {
 
     private val strides = DefaultStrides(shape)
@@ -79,25 +79,29 @@ class StreamRealNDField(
         return NDBuffer(strides, array.asBuffer())
     }
 
-    override fun power(arg: NDStructure<Double>, pow: Number): NDBuffer<Double> = arg.map() { power(it, pow) }
+    override fun NDStructure<Double>.unaryMinus(): NDStructure<Double> = map { -it }
 
-    override fun exp(arg: NDStructure<Double>): NDBuffer<Double> = arg.map() { exp(it) }
+    override fun scale(a: NDStructure<Double>, value: Double): NDStructure<Double> = a.map { it * value }
 
-    override fun ln(arg: NDStructure<Double>): NDBuffer<Double> = arg.map() { ln(it) }
+    override fun power(arg: NDStructure<Double>, pow: Number): NDBuffer<Double> = arg.map { power(it, pow) }
 
-    override fun sin(arg: NDStructure<Double>): NDBuffer<Double> = arg.map() { sin(it) }
-    override fun cos(arg: NDStructure<Double>): NDBuffer<Double> = arg.map() { cos(it) }
-    override fun tan(arg: NDStructure<Double>): NDBuffer<Double> = arg.map() { tan(it) }
-    override fun asin(arg: NDStructure<Double>): NDBuffer<Double> = arg.map() { asin(it) }
-    override fun acos(arg: NDStructure<Double>): NDBuffer<Double> = arg.map() { acos(it) }
-    override fun atan(arg: NDStructure<Double>): NDBuffer<Double> = arg.map() { atan(it) }
+    override fun exp(arg: NDStructure<Double>): NDBuffer<Double> = arg.map { exp(it) }
 
-    override fun sinh(arg: NDStructure<Double>): NDBuffer<Double> = arg.map() { sinh(it) }
-    override fun cosh(arg: NDStructure<Double>): NDBuffer<Double> = arg.map() { cosh(it) }
-    override fun tanh(arg: NDStructure<Double>): NDBuffer<Double> = arg.map() { tanh(it) }
-    override fun asinh(arg: NDStructure<Double>): NDBuffer<Double> = arg.map() { asinh(it) }
-    override fun acosh(arg: NDStructure<Double>): NDBuffer<Double> = arg.map() { acosh(it) }
-    override fun atanh(arg: NDStructure<Double>): NDBuffer<Double> = arg.map() { atanh(it) }
+    override fun ln(arg: NDStructure<Double>): NDBuffer<Double> = arg.map { ln(it) }
+
+    override fun sin(arg: NDStructure<Double>): NDBuffer<Double> = arg.map { sin(it) }
+    override fun cos(arg: NDStructure<Double>): NDBuffer<Double> = arg.map { cos(it) }
+    override fun tan(arg: NDStructure<Double>): NDBuffer<Double> = arg.map { tan(it) }
+    override fun asin(arg: NDStructure<Double>): NDBuffer<Double> = arg.map { asin(it) }
+    override fun acos(arg: NDStructure<Double>): NDBuffer<Double> = arg.map { acos(it) }
+    override fun atan(arg: NDStructure<Double>): NDBuffer<Double> = arg.map { atan(it) }
+
+    override fun sinh(arg: NDStructure<Double>): NDBuffer<Double> = arg.map { sinh(it) }
+    override fun cosh(arg: NDStructure<Double>): NDBuffer<Double> = arg.map { cosh(it) }
+    override fun tanh(arg: NDStructure<Double>): NDBuffer<Double> = arg.map { tanh(it) }
+    override fun asinh(arg: NDStructure<Double>): NDBuffer<Double> = arg.map { asinh(it) }
+    override fun acosh(arg: NDStructure<Double>): NDBuffer<Double> = arg.map { acosh(it) }
+    override fun atanh(arg: NDStructure<Double>): NDBuffer<Double> = arg.map { atanh(it) }
 }
 
 fun NDAlgebra.Companion.realWithStream(vararg shape: Int): StreamRealNDField = StreamRealNDField(shape)
\ No newline at end of file
diff --git a/gradle.properties b/gradle.properties
index 1a2a263ac..aadc76c52 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1,9 +1,10 @@
 kotlin.code.style=official
-kotlin.mpp.enableGranularSourceSetsMetadata=true
 kotlin.mpp.stability.nowarn=true
-kotlin.native.enableDependencyPropagation=false
 kotlin.parallel.tasks.in.project=true
 org.gradle.configureondemand=true
 org.gradle.jvmargs=-XX:MaxMetaspaceSize=512m
 org.gradle.parallel=true
-systemProp.org.gradle.internal.publish.checksums.insecure=true
+
+kotlin.mpp.enableGranularSourceSetsMetadata=true
+kotlin.native.enableDependencyPropagation=false
+
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index 2a563242c..442d9132e 100644
--- 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-6.8.2-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.8.3-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
diff --git a/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/MstAlgebra.kt b/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/MstAlgebra.kt
index 7bea65684..047ee187d 100644
--- a/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/MstAlgebra.kt
+++ b/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/MstAlgebra.kt
@@ -20,8 +20,8 @@ public object MstAlgebra : NumericAlgebra<MST> {
 /**
  * [Space] over [MST] nodes.
  */
-public object MstSpace : Space<MST>, NumericAlgebra<MST> {
-    public override val zero: MST.Numeric by lazy { number(0.0) }
+public object MstSpace : Space<MST>, NumericAlgebra<MST>, ScaleOperations<MST> {
+    public override val zero: MST.Numeric = number(0.0)
 
     public override fun number(value: Number): MST.Numeric = MstAlgebra.number(value)
     public override fun bindSymbol(value: String): MST.Symbolic = MstAlgebra.bindSymbol(value)
@@ -35,8 +35,8 @@ public object MstSpace : Space<MST>, NumericAlgebra<MST> {
     public override operator fun MST.minus(b: MST): MST.Binary =
         binaryOperationFunction(SpaceOperations.MINUS_OPERATION)(this, b)
 
-    public override fun multiply(a: MST, k: Number): MST.Binary =
-        binaryOperationFunction(RingOperations.TIMES_OPERATION)(a, number(k))
+    public override fun scale(a: MST, value: Double): MST.Binary =
+        binaryOperationFunction(RingOperations.TIMES_OPERATION)(a, number(value))
 
     public override fun binaryOperationFunction(operation: String): (left: MST, right: MST) -> MST.Binary =
         MstAlgebra.binaryOperationFunction(operation)
@@ -49,16 +49,17 @@ public object MstSpace : Space<MST>, NumericAlgebra<MST> {
  * [Ring] over [MST] nodes.
  */
 @OptIn(UnstableKMathAPI::class)
-public object MstRing : Ring<MST>, RingWithNumbers<MST> {
-    public override val zero: MST.Numeric
-        get() = MstSpace.zero
-
-    public override val one: MST.Numeric by lazy { number(1.0) }
+public object MstRing : Ring<MST>, NumbersAddOperations<MST>, ScaleOperations<MST> {
+    public override val zero: MST.Numeric = MstSpace.zero
+    public override val one: MST.Numeric = number(1.0)
 
     public override fun number(value: Number): MST.Numeric = MstSpace.number(value)
     public override fun bindSymbol(value: String): MST.Symbolic = MstSpace.bindSymbol(value)
     public override fun add(a: MST, b: MST): MST.Binary = MstSpace.add(a, b)
-    public override fun multiply(a: MST, k: Number): MST.Binary = MstSpace.multiply(a, k)
+
+    public override fun scale(a: MST, value: Double): MST.Binary =
+        MstSpace.binaryOperationFunction(RingOperations.TIMES_OPERATION)(a, MstSpace.number(value))
+
     public override fun multiply(a: MST, b: MST): MST.Binary =
         binaryOperationFunction(RingOperations.TIMES_OPERATION)(a, b)
 
@@ -77,17 +78,18 @@ public object MstRing : Ring<MST>, RingWithNumbers<MST> {
  * [Field] over [MST] nodes.
  */
 @OptIn(UnstableKMathAPI::class)
-public object MstField : Field<MST>, RingWithNumbers<MST> {
-    public override val zero: MST.Numeric
-        get() = MstRing.zero
+public object MstField : Field<MST>, NumbersAddOperations<MST>, ScaleOperations<MST> {
+    public override val zero: MST.Numeric get() = MstRing.zero
 
-    public override val one: MST.Numeric
-        get() = MstRing.one
+    public override val one: MST.Numeric get() = MstRing.one
 
     public override fun bindSymbol(value: String): MST.Symbolic = MstRing.bindSymbol(value)
     public override fun number(value: Number): MST.Numeric = MstRing.number(value)
     public override fun add(a: MST, b: MST): MST.Binary = MstRing.add(a, b)
-    public override fun multiply(a: MST, k: Number): MST.Binary = MstRing.multiply(a, k)
+
+    public override fun scale(a: MST, value: Double): MST.Binary =
+        MstSpace.binaryOperationFunction(RingOperations.TIMES_OPERATION)(a, MstSpace.number(value))
+
     public override fun multiply(a: MST, b: MST): MST.Binary = MstRing.multiply(a, b)
     public override fun divide(a: MST, b: MST): MST.Binary =
         binaryOperationFunction(FieldOperations.DIV_OPERATION)(a, b)
@@ -107,11 +109,8 @@ public object MstField : Field<MST>, RingWithNumbers<MST> {
  * [ExtendedField] over [MST] nodes.
  */
 public object MstExtendedField : ExtendedField<MST>, NumericAlgebra<MST> {
-    public override val zero: MST.Numeric
-        get() = MstField.zero
-
-    public override val one: MST.Numeric
-        get() = MstField.one
+    public override val zero: MST.Numeric = MstField.zero
+    public override val one: MST.Numeric = MstField.one
 
     public override fun bindSymbol(value: String): MST.Symbolic = MstField.bindSymbol(value)
     public override fun number(value: Number): MST.Numeric = MstRing.number(value)
@@ -121,14 +120,17 @@ public object MstExtendedField : ExtendedField<MST>, NumericAlgebra<MST> {
     public override fun asin(arg: MST): MST.Unary = unaryOperationFunction(TrigonometricOperations.ASIN_OPERATION)(arg)
     public override fun acos(arg: MST): MST.Unary = unaryOperationFunction(TrigonometricOperations.ACOS_OPERATION)(arg)
     public override fun atan(arg: MST): MST.Unary = unaryOperationFunction(TrigonometricOperations.ATAN_OPERATION)(arg)
-    public override fun sinh(arg: MST): MST.Unary = unaryOperationFunction(HyperbolicOperations.SINH_OPERATION)(arg)
-    public override fun cosh(arg: MST): MST.Unary = unaryOperationFunction(HyperbolicOperations.COSH_OPERATION)(arg)
-    public override fun tanh(arg: MST): MST.Unary = unaryOperationFunction(HyperbolicOperations.TANH_OPERATION)(arg)
-    public override fun asinh(arg: MST): MST.Unary = unaryOperationFunction(HyperbolicOperations.ASINH_OPERATION)(arg)
-    public override fun acosh(arg: MST): MST.Unary = unaryOperationFunction(HyperbolicOperations.ACOSH_OPERATION)(arg)
-    public override fun atanh(arg: MST): MST.Unary = unaryOperationFunction(HyperbolicOperations.ATANH_OPERATION)(arg)
+    public override fun sinh(arg: MST): MST.Unary = unaryOperationFunction(ExponentialOperations.SINH_OPERATION)(arg)
+    public override fun cosh(arg: MST): MST.Unary = unaryOperationFunction(ExponentialOperations.COSH_OPERATION)(arg)
+    public override fun tanh(arg: MST): MST.Unary = unaryOperationFunction(ExponentialOperations.TANH_OPERATION)(arg)
+    public override fun asinh(arg: MST): MST.Unary = unaryOperationFunction(ExponentialOperations.ASINH_OPERATION)(arg)
+    public override fun acosh(arg: MST): MST.Unary = unaryOperationFunction(ExponentialOperations.ACOSH_OPERATION)(arg)
+    public override fun atanh(arg: MST): MST.Unary = unaryOperationFunction(ExponentialOperations.ATANH_OPERATION)(arg)
     public override fun add(a: MST, b: MST): MST.Binary = MstField.add(a, b)
-    public override fun multiply(a: MST, k: Number): MST.Binary = MstField.multiply(a, k)
+
+    public override fun scale(a: MST, value: Double): MST =
+        binaryOperation(SpaceOperations.PLUS_OPERATION, a, number(value))
+
     public override fun multiply(a: MST, b: MST): MST.Binary = MstField.multiply(a, b)
     public override fun divide(a: MST, b: MST): MST.Binary = MstField.divide(a, b)
     public override operator fun MST.unaryPlus(): MST.Unary = MstField { +this@unaryPlus }
diff --git a/kmath-ast/src/jsTest/kotlin/space/kscience/kmath/estree/TestESTreeConsistencyWithInterpreter.kt b/kmath-ast/src/jsTest/kotlin/space/kscience/kmath/estree/TestESTreeConsistencyWithInterpreter.kt
index 492a5d11f..c91cc4daf 100644
--- a/kmath-ast/src/jsTest/kotlin/space/kscience/kmath/estree/TestESTreeConsistencyWithInterpreter.kt
+++ b/kmath-ast/src/jsTest/kotlin/space/kscience/kmath/estree/TestESTreeConsistencyWithInterpreter.kt
@@ -15,9 +15,9 @@ internal class TestESTreeConsistencyWithInterpreter {
         val res1 = MstSpace.mstInSpace {
             binaryOperationFunction("+")(
                 unaryOperationFunction("+")(
-                    number(3.toByte()) - (number(2.toByte()) + (multiply(
+                    number(3.toByte()) - (number(2.toByte()) + (scale(
                         add(number(1), number(1)),
-                        2
+                        2.0
                     ) + number(1.toByte()) * 3.toByte() - number(1.toByte())))
                 ),
 
@@ -28,9 +28,9 @@ internal class TestESTreeConsistencyWithInterpreter {
         val res2 = MstSpace.mstInSpace {
             binaryOperationFunction("+")(
                 unaryOperationFunction("+")(
-                    number(3.toByte()) - (number(2.toByte()) + (multiply(
+                    number(3.toByte()) - (number(2.toByte()) + (scale(
                         add(number(1), number(1)),
-                        2
+                        2.0
                     ) + number(1.toByte()) * 3.toByte() - number(1.toByte())))
                 ),
 
@@ -46,9 +46,9 @@ internal class TestESTreeConsistencyWithInterpreter {
         val res1 = ByteRing.mstInRing {
             binaryOperationFunction("+")(
                 unaryOperationFunction("+")(
-                    (bindSymbol("x") - (2.toByte() + (multiply(
+                    (bindSymbol("x") - (2.toByte() + (scale(
                         add(number(1), number(1)),
-                        2
+                        2.0
                     ) + 1.toByte()))) * 3.0 - 1.toByte()
                 ),
 
@@ -59,9 +59,9 @@ internal class TestESTreeConsistencyWithInterpreter {
         val res2 = ByteRing.mstInRing {
             binaryOperationFunction("+")(
                 unaryOperationFunction("+")(
-                    (bindSymbol("x") - (2.toByte() + (multiply(
+                    (bindSymbol("x") - (2.toByte() + (scale(
                         add(number(1), number(1)),
-                        2
+                        2.0
                     ) + 1.toByte()))) * 3.0 - 1.toByte()
                 ),
                 number(1)
@@ -75,7 +75,7 @@ internal class TestESTreeConsistencyWithInterpreter {
     fun realField() {
         val res1 = RealField.mstInField {
             +(3 - 2 + 2 * number(1) + 1.0) + binaryOperationFunction("+")(
-                (3.0 - (bindSymbol("x") + (multiply(add(number(1.0), number(1.0)), 2) + 1.0))) * 3 - 1.0
+                (3.0 - (bindSymbol("x") + (scale(add(number(1.0), number(1.0)), 2.0) + 1.0))) * 3 - 1.0
                         + number(1),
                 number(1) / 2 + number(2.0) * one
             ) + zero
@@ -83,7 +83,7 @@ internal class TestESTreeConsistencyWithInterpreter {
 
         val res2 = RealField.mstInField {
             +(3 - 2 + 2 * number(1) + 1.0) + binaryOperationFunction("+")(
-                (3.0 - (bindSymbol("x") + (multiply(add(number(1.0), number(1.0)), 2) + 1.0))) * 3 - 1.0
+                (3.0 - (bindSymbol("x") + (scale(add(number(1.0), number(1.0)), 2.0) + 1.0))) * 3 - 1.0
                         + number(1),
                 number(1) / 2 + number(2.0) * one
             ) + zero
@@ -96,7 +96,7 @@ internal class TestESTreeConsistencyWithInterpreter {
     fun complexField() {
         val res1 = ComplexField.mstInField {
             +(3 - 2 + 2 * number(1) + 1.0) + binaryOperationFunction("+")(
-                (3.0 - (bindSymbol("x") + (multiply(add(number(1.0), number(1.0)), 2) + 1.0))) * 3 - 1.0
+                (3.0 - (bindSymbol("x") + (scale(add(number(1.0), number(1.0)), 2.0) + 1.0))) * 3 - 1.0
                         + number(1),
                 number(1) / 2 + number(2.0) * one
             ) + zero
@@ -104,7 +104,7 @@ internal class TestESTreeConsistencyWithInterpreter {
 
         val res2 = ComplexField.mstInField {
             +(3 - 2 + 2 * number(1) + 1.0) + binaryOperationFunction("+")(
-                (3.0 - (bindSymbol("x") + (multiply(add(number(1.0), number(1.0)), 2) + 1.0))) * 3 - 1.0
+                (3.0 - (bindSymbol("x") + (scale(add(number(1.0), number(1.0)), 2.0) + 1.0))) * 3 - 1.0
                         + number(1),
                 number(1) / 2 + number(2.0) * one
             ) + zero
diff --git a/kmath-ast/src/jvmTest/kotlin/space/kscience/kmath/asm/TestAsmConsistencyWithInterpreter.kt b/kmath-ast/src/jvmTest/kotlin/space/kscience/kmath/asm/TestAsmConsistencyWithInterpreter.kt
index 0f2328db6..5c6297f3f 100644
--- a/kmath-ast/src/jvmTest/kotlin/space/kscience/kmath/asm/TestAsmConsistencyWithInterpreter.kt
+++ b/kmath-ast/src/jvmTest/kotlin/space/kscience/kmath/asm/TestAsmConsistencyWithInterpreter.kt
@@ -15,9 +15,9 @@ internal class TestAsmConsistencyWithInterpreter {
         val res1 = MstSpace.mstInSpace {
             binaryOperationFunction("+")(
                 unaryOperationFunction("+")(
-                    number(3.toByte()) - (number(2.toByte()) + (multiply(
+                    number(3.toByte()) - (number(2.toByte()) + (scale(
                         add(number(1), number(1)),
-                        2
+                        2.0
                     ) + number(1.toByte()) * 3.toByte() - number(1.toByte())))
                 ),
 
@@ -28,9 +28,9 @@ internal class TestAsmConsistencyWithInterpreter {
         val res2 = MstSpace.mstInSpace {
             binaryOperationFunction("+")(
                 unaryOperationFunction("+")(
-                    number(3.toByte()) - (number(2.toByte()) + (multiply(
+                    number(3.toByte()) - (number(2.toByte()) + (scale(
                         add(number(1), number(1)),
-                        2
+                        2.0
                     ) + number(1.toByte()) * 3.toByte() - number(1.toByte())))
                 ),
 
@@ -46,9 +46,9 @@ internal class TestAsmConsistencyWithInterpreter {
         val res1 = ByteRing.mstInRing {
             binaryOperationFunction("+")(
                 unaryOperationFunction("+")(
-                    (bindSymbol("x") - (2.toByte() + (multiply(
+                    (bindSymbol("x") - (2.toByte() + (scale(
                         add(number(1), number(1)),
-                        2
+                        2.0
                     ) + 1.toByte()))) * 3.0 - 1.toByte()
                 ),
 
@@ -59,9 +59,9 @@ internal class TestAsmConsistencyWithInterpreter {
         val res2 = ByteRing.mstInRing {
             binaryOperationFunction("+")(
                 unaryOperationFunction("+")(
-                    (bindSymbol("x") - (2.toByte() + (multiply(
+                    (bindSymbol("x") - (2.toByte() + (scale(
                         add(number(1), number(1)),
-                        2
+                        2.0
                     ) + 1.toByte()))) * 3.0 - 1.toByte()
                 ),
                 number(1)
@@ -75,7 +75,7 @@ internal class TestAsmConsistencyWithInterpreter {
     fun realField() {
         val res1 = RealField.mstInField {
             +(3 - 2 + 2 * number(1) + 1.0) + binaryOperationFunction("+")(
-                (3.0 - (bindSymbol("x") + (multiply(add(number(1.0), number(1.0)), 2) + 1.0))) * 3 - 1.0
+                (3.0 - (bindSymbol("x") + (scale(add(number(1.0), number(1.0)), 2.0) + 1.0))) * 3 - 1.0
                         + number(1),
                 number(1) / 2 + number(2.0) * one
             ) + zero
@@ -83,7 +83,7 @@ internal class TestAsmConsistencyWithInterpreter {
 
         val res2 = RealField.mstInField {
             +(3 - 2 + 2 * number(1) + 1.0) + binaryOperationFunction("+")(
-                (3.0 - (bindSymbol("x") + (multiply(add(number(1.0), number(1.0)), 2) + 1.0))) * 3 - 1.0
+                (3.0 - (bindSymbol("x") + (scale(add(number(1.0), number(1.0)), 2.0) + 1.0))) * 3 - 1.0
                         + number(1),
                 number(1) / 2 + number(2.0) * one
             ) + zero
@@ -96,7 +96,7 @@ internal class TestAsmConsistencyWithInterpreter {
     fun complexField() {
         val res1 = ComplexField.mstInField {
             +(3 - 2 + 2 * number(1) + 1.0) + binaryOperationFunction("+")(
-                (3.0 - (bindSymbol("x") + (multiply(add(number(1.0), number(1.0)), 2) + 1.0))) * 3 - 1.0
+                (3.0 - (bindSymbol("x") + (scale(add(number(1.0), number(1.0)), 2.0) + 1.0))) * 3 - 1.0
                         + number(1),
                 number(1) / 2 + number(2.0) * one
             ) + zero
@@ -104,7 +104,7 @@ internal class TestAsmConsistencyWithInterpreter {
 
         val res2 = ComplexField.mstInField {
             +(3 - 2 + 2 * number(1) + 1.0) + binaryOperationFunction("+")(
-                (3.0 - (bindSymbol("x") + (multiply(add(number(1.0), number(1.0)), 2) + 1.0))) * 3 - 1.0
+                (3.0 - (bindSymbol("x") + (scale(add(number(1.0), number(1.0)), 2.0) + 1.0))) * 3 - 1.0
                         + number(1),
                 number(1) / 2 + number(2.0) * one
             ) + zero
diff --git 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
index 8342a8071..b74167c3f 100644
--- 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
@@ -4,7 +4,7 @@ import org.apache.commons.math3.analysis.differentiation.DerivativeStructure
 import space.kscience.kmath.expressions.*
 import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.operations.ExtendedField
-import space.kscience.kmath.operations.RingWithNumbers
+import space.kscience.kmath.operations.NumbersAddOperations
 
 /**
  * A field over commons-math [DerivativeStructure].
@@ -16,7 +16,8 @@ import space.kscience.kmath.operations.RingWithNumbers
 public class DerivativeStructureField(
     public val order: Int,
     bindings: Map<Symbol, Double>,
-) : ExtendedField<DerivativeStructure>, ExpressionAlgebra<Double, DerivativeStructure>, RingWithNumbers<DerivativeStructure> {
+) : ExtendedField<DerivativeStructure>, ExpressionAlgebra<Double, DerivativeStructure>,
+    NumbersAddOperations<DerivativeStructure> {
     public val numberOfVariables: Int = bindings.size
 
     public override val zero: DerivativeStructure by lazy { DerivativeStructure(numberOfVariables, order) }
@@ -62,13 +63,11 @@ public class DerivativeStructureField(
 
     public fun DerivativeStructure.derivative(vararg symbols: Symbol): Double = derivative(symbols.toList())
 
+    override fun DerivativeStructure.unaryMinus(): DerivativeStructure = negate()
+
     public override fun add(a: DerivativeStructure, b: DerivativeStructure): DerivativeStructure = a.add(b)
 
-    public override fun multiply(a: DerivativeStructure, k: Number): DerivativeStructure = when (k) {
-        is Double -> a.multiply(k)
-        is Int -> a.multiply(k)
-        else -> a.multiply(k.toDouble())
-    }
+    public override fun scale(a: DerivativeStructure, value: Double): DerivativeStructure = a.multiply(value)
 
     public override fun multiply(a: DerivativeStructure, b: DerivativeStructure): DerivativeStructure = a.multiply(b)
     public override fun divide(a: DerivativeStructure, b: DerivativeStructure): DerivativeStructure = a.divide(b)
diff --git 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
index 3638b9808..537da5947 100644
--- 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
@@ -101,8 +101,8 @@ public object CMMatrixContext : MatrixContext<Double, CMMatrix> {
     public override operator fun Matrix<Double>.minus(b: Matrix<Double>): CMMatrix =
         CMMatrix(toCM().origin.subtract(b.toCM().origin))
 
-    public override fun multiply(a: Matrix<Double>, k: Number): CMMatrix =
-        CMMatrix(a.toCM().origin.scalarMultiply(k.toDouble()))
+//    public override fun multiply(a: Matrix<Double>, k: Number): CMMatrix =
+//        CMMatrix(a.toCM().origin.scalarMultiply(k.toDouble()))
 
     public override operator fun Matrix<Double>.times(value: Double): CMMatrix =
         produce(rowNum, colNum) { i, j -> get(i, j) * value }
diff --git a/kmath-complex/src/commonMain/kotlin/space/kscience/kmath/complex/Complex.kt b/kmath-complex/src/commonMain/kotlin/space/kscience/kmath/complex/Complex.kt
index deadfda5b..a73fb0201 100644
--- a/kmath-complex/src/commonMain/kotlin/space/kscience/kmath/complex/Complex.kt
+++ b/kmath-complex/src/commonMain/kotlin/space/kscience/kmath/complex/Complex.kt
@@ -4,10 +4,7 @@ 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.ExtendedField
-import space.kscience.kmath.operations.FieldElement
-import space.kscience.kmath.operations.Norm
-import space.kscience.kmath.operations.RingWithNumbers
+import space.kscience.kmath.operations.*
 import space.kscience.kmath.structures.Buffer
 import space.kscience.kmath.structures.MemoryBuffer
 import space.kscience.kmath.structures.MutableBuffer
@@ -47,7 +44,8 @@ private val PI_DIV_2 = Complex(PI / 2, 0)
  * A field of [Complex].
  */
 @OptIn(UnstableKMathAPI::class)
-public object ComplexField : ExtendedField<Complex>, Norm<Complex, Complex>, RingWithNumbers<Complex> {
+public object ComplexField : ExtendedField<Complex>, Norm<Complex, Complex>, NumbersAddOperations<Complex>,
+    ScaleOperations<Complex> {
     public override val zero: Complex = 0.0.toComplex()
     public override val one: Complex = 1.0.toComplex()
 
@@ -56,8 +54,14 @@ public object ComplexField : ExtendedField<Complex>, Norm<Complex, Complex>, Rin
      */
     public val i: Complex by lazy { Complex(0.0, 1.0) }
 
+    override fun Complex.unaryMinus(): Complex = Complex(-re, -im)
+
+    override fun number(value: Number): Complex = Complex(value.toDouble(), 0.0)
+
+    override fun scale(a: Complex, value: Double): Complex = Complex(a.re * value, a.im * value)
+
     public override fun add(a: Complex, b: Complex): Complex = Complex(a.re + b.re, a.im + b.im)
-    public override fun multiply(a: Complex, k: Number): Complex = Complex(a.re * k.toDouble(), a.im * k.toDouble())
+//    public override fun multiply(a: Complex, k: Number): Complex = Complex(a.re * k.toDouble(), a.im * k.toDouble())
 
     public override fun multiply(a: Complex, b: Complex): Complex =
         Complex(a.re * b.re - a.im * b.im, a.re * b.im + a.im * b.re)
@@ -86,8 +90,10 @@ public object ComplexField : ExtendedField<Complex>, Norm<Complex, Complex>, Rin
         }
     }
 
-    public override fun sin(arg: Complex): Complex = i * (exp(-i * arg) - exp(i * arg)) / 2
-    public override fun cos(arg: Complex): Complex = (exp(-i * arg) + exp(i * arg)) / 2
+    override operator fun Complex.div(k: Number): Complex = Complex(re / k.toDouble(), im / k.toDouble())
+
+    public override fun sin(arg: Complex): Complex = i * (exp(-i * arg) - exp(i * arg)) / 2.0
+    public override fun cos(arg: Complex): Complex = (exp(-i * arg) + exp(i * arg)) / 2.0
 
     public override fun tan(arg: Complex): Complex {
         val e1 = exp(-i * arg)
@@ -159,7 +165,8 @@ public object ComplexField : ExtendedField<Complex>, Norm<Complex, Complex>, Rin
 
     public override fun norm(arg: Complex): Complex = sqrt(arg.conjugate * arg)
 
-    public override fun bindSymbol(value: String): Complex = if (value == "i") i else super<ExtendedField>.bindSymbol(value)
+    public override fun bindSymbol(value: String): Complex =
+        if (value == "i") i else super<ExtendedField>.bindSymbol(value)
 }
 
 /**
@@ -181,7 +188,8 @@ public data class Complex(val re: Double, val im: Double) : FieldElement<Complex
         public override val objectSize: Int
             get() = 16
 
-        public override fun MemoryReader.read(offset: Int): Complex = Complex(readDouble(offset), readDouble(offset + 8))
+        public override fun MemoryReader.read(offset: Int): Complex =
+            Complex(readDouble(offset), readDouble(offset + 8))
 
         public override fun MemoryWriter.write(offset: Int, value: Complex) {
             writeDouble(offset, value.re)
diff --git a/kmath-complex/src/commonMain/kotlin/space/kscience/kmath/complex/ComplexNDField.kt b/kmath-complex/src/commonMain/kotlin/space/kscience/kmath/complex/ComplexNDField.kt
index 11cfea263..382659e10 100644
--- a/kmath-complex/src/commonMain/kotlin/space/kscience/kmath/complex/ComplexNDField.kt
+++ b/kmath-complex/src/commonMain/kotlin/space/kscience/kmath/complex/ComplexNDField.kt
@@ -6,7 +6,7 @@ import space.kscience.kmath.nd.NDAlgebra
 import space.kscience.kmath.nd.NDBuffer
 import space.kscience.kmath.nd.NDStructure
 import space.kscience.kmath.operations.ExtendedField
-import space.kscience.kmath.operations.RingWithNumbers
+import space.kscience.kmath.operations.NumbersAddOperations
 import space.kscience.kmath.structures.Buffer
 import kotlin.contracts.InvocationKind
 import kotlin.contracts.contract
@@ -19,7 +19,7 @@ import kotlin.contracts.contract
 public class ComplexNDField(
     shape: IntArray,
 ) : BufferedNDField<Complex, ComplexField>(shape, ComplexField, Buffer.Companion::complex),
-    RingWithNumbers<NDStructure<Complex>>,
+    NumbersAddOperations<NDStructure<Complex>>,
     ExtendedField<NDStructure<Complex>> {
 
     override val zero: NDBuffer<Complex> by lazy { produce { zero } }
@@ -29,6 +29,7 @@ public class ComplexNDField(
         val d = value.toComplex() // minimize conversions
         return produce { d }
     }
+
 //
 //    @Suppress("OVERRIDE_BY_INLINE")
 //    override inline fun map(
@@ -75,25 +76,25 @@ public class ComplexNDField(
 //        return BufferedNDFieldElement(this, buffer)
 //    }
 
-    override fun power(arg: NDStructure<Complex>, pow: Number): NDBuffer<Complex> = arg.map() { power(it, pow) }
+    override fun power(arg: NDStructure<Complex>, pow: Number): NDBuffer<Complex> = arg.map { power(it, pow) }
 
-    override fun exp(arg: NDStructure<Complex>): NDBuffer<Complex> = arg.map() { exp(it) }
+    override fun exp(arg: NDStructure<Complex>): NDBuffer<Complex> = arg.map { exp(it) }
 
-    override fun ln(arg: NDStructure<Complex>): NDBuffer<Complex> = arg.map() { ln(it) }
+    override fun ln(arg: NDStructure<Complex>): NDBuffer<Complex> = arg.map { ln(it) }
 
-    override fun sin(arg: NDStructure<Complex>): NDBuffer<Complex> = arg.map() { sin(it) }
-    override fun cos(arg: NDStructure<Complex>): NDBuffer<Complex> = arg.map() { cos(it) }
-    override fun tan(arg: NDStructure<Complex>): NDBuffer<Complex> = arg.map() { tan(it) }
-    override fun asin(arg: NDStructure<Complex>): NDBuffer<Complex> = arg.map() { asin(it) }
-    override fun acos(arg: NDStructure<Complex>): NDBuffer<Complex> = arg.map() { acos(it) }
-    override fun atan(arg: NDStructure<Complex>): NDBuffer<Complex> = arg.map() { atan(it) }
+    override fun sin(arg: NDStructure<Complex>): NDBuffer<Complex> = arg.map { sin(it) }
+    override fun cos(arg: NDStructure<Complex>): NDBuffer<Complex> = arg.map { cos(it) }
+    override fun tan(arg: NDStructure<Complex>): NDBuffer<Complex> = arg.map { tan(it) }
+    override fun asin(arg: NDStructure<Complex>): NDBuffer<Complex> = arg.map { asin(it) }
+    override fun acos(arg: NDStructure<Complex>): NDBuffer<Complex> = arg.map { acos(it) }
+    override fun atan(arg: NDStructure<Complex>): NDBuffer<Complex> = arg.map { atan(it) }
 
-    override fun sinh(arg: NDStructure<Complex>): NDBuffer<Complex> = arg.map() { sinh(it) }
-    override fun cosh(arg: NDStructure<Complex>): NDBuffer<Complex> = arg.map() { cosh(it) }
-    override fun tanh(arg: NDStructure<Complex>): NDBuffer<Complex> = arg.map() { tanh(it) }
-    override fun asinh(arg: NDStructure<Complex>): NDBuffer<Complex> = arg.map() { asinh(it) }
-    override fun acosh(arg: NDStructure<Complex>): NDBuffer<Complex> = arg.map() { acosh(it) }
-    override fun atanh(arg: NDStructure<Complex>): NDBuffer<Complex> = arg.map() { atanh(it) }
+    override fun sinh(arg: NDStructure<Complex>): NDBuffer<Complex> = arg.map { sinh(it) }
+    override fun cosh(arg: NDStructure<Complex>): NDBuffer<Complex> = arg.map { cosh(it) }
+    override fun tanh(arg: NDStructure<Complex>): NDBuffer<Complex> = arg.map { tanh(it) }
+    override fun asinh(arg: NDStructure<Complex>): NDBuffer<Complex> = arg.map { asinh(it) }
+    override fun acosh(arg: NDStructure<Complex>): NDBuffer<Complex> = arg.map { acosh(it) }
+    override fun atanh(arg: NDStructure<Complex>): NDBuffer<Complex> = arg.map { atanh(it) }
 }
 
 
diff --git a/kmath-complex/src/commonMain/kotlin/space/kscience/kmath/complex/Quaternion.kt b/kmath-complex/src/commonMain/kotlin/space/kscience/kmath/complex/Quaternion.kt
index 4a15e7423..d391aff18 100644
--- a/kmath-complex/src/commonMain/kotlin/space/kscience/kmath/complex/Quaternion.kt
+++ b/kmath-complex/src/commonMain/kotlin/space/kscience/kmath/complex/Quaternion.kt
@@ -37,7 +37,7 @@ public val Quaternion.r: Double
  */
 @OptIn(UnstableKMathAPI::class)
 public object QuaternionField : Field<Quaternion>, Norm<Quaternion, Quaternion>, PowerOperations<Quaternion>,
-    ExponentialOperations<Quaternion>, RingWithNumbers<Quaternion> {
+    ExponentialOperations<Quaternion>, NumbersAddOperations<Quaternion>, ScaleOperations<Quaternion> {
     override val zero: Quaternion = 0.toQuaternion()
     override val one: Quaternion = 1.toQuaternion()
 
@@ -59,10 +59,8 @@ public object QuaternionField : Field<Quaternion>, Norm<Quaternion, Quaternion>,
     public override fun add(a: Quaternion, b: Quaternion): Quaternion =
         Quaternion(a.w + b.w, a.x + b.x, a.y + b.y, a.z + b.z)
 
-    public override fun multiply(a: Quaternion, k: Number): Quaternion {
-        val d = k.toDouble()
-        return Quaternion(a.w * d, a.x * d, a.y * d, a.z * d)
-    }
+    public override fun scale(a: Quaternion, value: Double): Quaternion =
+        Quaternion(a.w * value, a.x * value, a.y * value, a.z * value)
 
     public override fun multiply(a: Quaternion, b: Quaternion): Quaternion = Quaternion(
         a.w * b.w - a.x * b.x - a.y * b.y - a.z * b.z,
@@ -173,6 +171,15 @@ public object QuaternionField : Field<Quaternion>, Norm<Quaternion, Quaternion>,
         "k" -> k
         else -> super<Field>.bindSymbol(value)
     }
+
+    override fun number(value: Number): Quaternion =value.toQuaternion()
+
+    public override fun sinh(arg: Quaternion): Quaternion = (exp(arg) - exp(-arg)) / 2.0
+    public override fun cosh(arg: Quaternion): Quaternion = (exp(arg) + exp(-arg)) / 2.0
+    public override fun tanh(arg: Quaternion): Quaternion = (exp(arg) - exp(-arg)) / (exp(-arg) + exp(arg))
+    public override fun asinh(arg: Quaternion): Quaternion = ln(sqrt(arg * arg + one) + arg)
+    public override fun acosh(arg: Quaternion): Quaternion = ln(arg + sqrt((arg - one) * (arg + one)))
+    public override fun atanh(arg: Quaternion): Quaternion = (ln(arg + one) - ln(one - arg)) / 2.0
 }
 
 /**
@@ -207,8 +214,7 @@ public data class Quaternion(
         require(!z.isNaN()) { "x-component of quaternion is not-a-number" }
     }
 
-    public override val context: QuaternionField
-        get() = QuaternionField
+    public override val context: QuaternionField get() = QuaternionField
 
     /**
      * Returns a string representation of this quaternion.
diff --git a/kmath-complex/src/commonTest/kotlin/space/kscience/kmath/complex/ExpressionFieldForComplexTest.kt b/kmath-complex/src/commonTest/kotlin/space/kscience/kmath/complex/ExpressionFieldForComplexTest.kt
index 43560b35a..81a131318 100644
--- a/kmath-complex/src/commonTest/kotlin/space/kscience/kmath/complex/ExpressionFieldForComplexTest.kt
+++ b/kmath-complex/src/commonTest/kotlin/space/kscience/kmath/complex/ExpressionFieldForComplexTest.kt
@@ -4,7 +4,6 @@ import space.kscience.kmath.expressions.FunctionalExpressionField
 import space.kscience.kmath.expressions.bindSymbol
 import space.kscience.kmath.expressions.invoke
 import space.kscience.kmath.expressions.symbol
-import space.kscience.kmath.operations.invoke
 import kotlin.test.Test
 import kotlin.test.assertEquals
 
@@ -13,14 +12,11 @@ internal class ExpressionFieldForComplexTest {
 
     @Test
     fun testComplex() {
-        val context = FunctionalExpressionField(ComplexField)
-
-        val expression = context {
+        val expression = FunctionalExpressionField(ComplexField).run {
             val x = bindSymbol(x)
             x * x + 2 * x + one
         }
 
         assertEquals(expression(x to Complex(1.0, 0.0)), Complex(4.0, 0.0))
-        //assertEquals(expression(), Complex(9.0, 0.0))
     }
 }
diff --git a/kmath-core/README.md b/kmath-core/README.md
deleted file mode 100644
index 54380670d..000000000
--- a/kmath-core/README.md
+++ /dev/null
@@ -1,55 +0,0 @@
-# The Core Module (`kmath-core`)
-
-The core features of KMath:
-
- - [algebras](src/commonMain/kotlin/kscience/kmath/operations/Algebra.kt) : Algebraic structures like rings, spaces and fields.
- - [nd](src/commonMain/kotlin/kscience/kmath/structures/NDStructure.kt) : Many-dimensional structures and operations on them.
- - [linear](src/commonMain/kotlin/kscience/kmath/operations/Algebra.kt) : Basic linear algebra operations (sums, products, etc.), backed by the `Space` API. Advanced linear algebra operations like matrix inversion and LU decomposition.
- - [buffers](src/commonMain/kotlin/kscience/kmath/structures/Buffers.kt) : One-dimensional structure
- - [expressions](src/commonMain/kotlin/kscience/kmath/expressions) : By writing a single mathematical expression once, users will be able to apply different types of 
-objects to the expression by providing a context. Expressions can be used for a wide variety of purposes from high 
-performance calculations to code generation.
- - [domains](src/commonMain/kotlin/kscience/kmath/domains) : Domains
- - [autodif](src/commonMain/kotlin/kscience/kmath/expressions/SimpleAutoDiff.kt) : Automatic differentiation
-
-
-> #### Artifact:
->
-> This module artifact: `space.kscience:kmath-core:0.2.0`.
->
-> Bintray release version:        [ ![Download](https://api.bintray.com/packages/mipt-npm/kscience/kmath-core/images/download.svg) ](https://bintray.com/mipt-npm/kscience/kmath-core/_latestVersion)
->
-> Bintray development version:    [ ![Download](https://api.bintray.com/packages/mipt-npm/dev/kmath-core/images/download.svg) ](https://bintray.com/mipt-npm/dev/kmath-core/_latestVersion)
->
-> **Gradle:**
->
-> ```gradle
-> repositories {
->     maven { url 'https://repo.kotlin.link' }
->     maven { url 'https://dl.bintray.com/hotkeytlt/maven' }
->     maven { url "https://dl.bintray.com/kotlin/kotlin-eap" } // include for builds based on kotlin-eap
->//     Uncomment if repo.kotlin.link is unavailable 
->//     maven { url 'https://dl.bintray.com/mipt-npm/kscience' }
->//     maven { url 'https://dl.bintray.com/mipt-npm/dev' }
-> }
-> 
-> dependencies {
->     implementation 'space.kscience:kmath-core:0.2.0'
-> }
-> ```
-> **Gradle Kotlin DSL:**
->
-> ```kotlin
-> repositories {
->     maven("https://repo.kotlin.link")
->     maven("https://dl.bintray.com/kotlin/kotlin-eap") // include for builds based on kotlin-eap
->     maven("https://dl.bintray.com/hotkeytlt/maven") // required for a
->//     Uncomment if repo.kotlin.link is unavailable 
->//     maven("https://dl.bintray.com/mipt-npm/kscience")
->//     maven("https://dl.bintray.com/mipt-npm/dev")
-> }
-> 
-> dependencies {
->     implementation("space.kscience:kmath-core:0.2.0")
-> }
-> ```
diff --git a/kmath-core/api/kmath-core.api b/kmath-core/api/kmath-core.api
index 4a21a3d7e..0efe430ad 100644
--- a/kmath-core/api/kmath-core.api
+++ b/kmath-core/api/kmath-core.api
@@ -3,70 +3,6 @@ public abstract interface class space/kscience/kmath/domains/Domain {
 	public abstract fun getDimension ()I
 }
 
-public final class space/kscience/kmath/domains/HyperSquareDomain : space/kscience/kmath/domains/RealDomain {
-	public fun <init> (Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)V
-	public fun contains (Lspace/kscience/kmath/structures/Buffer;)Z
-	public fun getDimension ()I
-	public fun getLowerBound (I)Ljava/lang/Double;
-	public fun getLowerBound (ILspace/kscience/kmath/structures/Buffer;)Ljava/lang/Double;
-	public fun getUpperBound (I)Ljava/lang/Double;
-	public fun getUpperBound (ILspace/kscience/kmath/structures/Buffer;)Ljava/lang/Double;
-	public fun nearestInDomain (Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-	public fun volume ()D
-}
-
-public abstract interface class space/kscience/kmath/domains/RealDomain : space/kscience/kmath/domains/Domain {
-	public abstract fun getLowerBound (I)Ljava/lang/Double;
-	public abstract fun getLowerBound (ILspace/kscience/kmath/structures/Buffer;)Ljava/lang/Double;
-	public abstract fun getUpperBound (I)Ljava/lang/Double;
-	public abstract fun getUpperBound (ILspace/kscience/kmath/structures/Buffer;)Ljava/lang/Double;
-	public abstract fun nearestInDomain (Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-	public abstract fun volume ()D
-}
-
-public final class space/kscience/kmath/domains/UnconstrainedDomain : space/kscience/kmath/domains/RealDomain {
-	public fun <init> (I)V
-	public fun contains (Lspace/kscience/kmath/structures/Buffer;)Z
-	public fun getDimension ()I
-	public fun getLowerBound (I)Ljava/lang/Double;
-	public fun getLowerBound (ILspace/kscience/kmath/structures/Buffer;)Ljava/lang/Double;
-	public fun getUpperBound (I)Ljava/lang/Double;
-	public fun getUpperBound (ILspace/kscience/kmath/structures/Buffer;)Ljava/lang/Double;
-	public fun nearestInDomain (Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-	public fun volume ()D
-}
-
-public final class space/kscience/kmath/domains/UnivariateDomain : space/kscience/kmath/domains/RealDomain {
-	public static final synthetic fun box-impl (Lkotlin/ranges/ClosedFloatingPointRange;)Lspace/kscience/kmath/domains/UnivariateDomain;
-	public static fun constructor-impl (Lkotlin/ranges/ClosedFloatingPointRange;)Lkotlin/ranges/ClosedFloatingPointRange;
-	public fun contains (Lspace/kscience/kmath/structures/Buffer;)Z
-	public static final fun contains-impl (Lkotlin/ranges/ClosedFloatingPointRange;D)Z
-	public static fun contains-impl (Lkotlin/ranges/ClosedFloatingPointRange;Lspace/kscience/kmath/structures/Buffer;)Z
-	public fun equals (Ljava/lang/Object;)Z
-	public static fun equals-impl (Lkotlin/ranges/ClosedFloatingPointRange;Ljava/lang/Object;)Z
-	public static final fun equals-impl0 (Lkotlin/ranges/ClosedFloatingPointRange;Lkotlin/ranges/ClosedFloatingPointRange;)Z
-	public fun getDimension ()I
-	public static fun getDimension-impl (Lkotlin/ranges/ClosedFloatingPointRange;)I
-	public fun getLowerBound (I)Ljava/lang/Double;
-	public fun getLowerBound (ILspace/kscience/kmath/structures/Buffer;)Ljava/lang/Double;
-	public static fun getLowerBound-impl (Lkotlin/ranges/ClosedFloatingPointRange;I)Ljava/lang/Double;
-	public static fun getLowerBound-impl (Lkotlin/ranges/ClosedFloatingPointRange;ILspace/kscience/kmath/structures/Buffer;)Ljava/lang/Double;
-	public final fun getRange ()Lkotlin/ranges/ClosedFloatingPointRange;
-	public fun getUpperBound (I)Ljava/lang/Double;
-	public fun getUpperBound (ILspace/kscience/kmath/structures/Buffer;)Ljava/lang/Double;
-	public static fun getUpperBound-impl (Lkotlin/ranges/ClosedFloatingPointRange;I)Ljava/lang/Double;
-	public static fun getUpperBound-impl (Lkotlin/ranges/ClosedFloatingPointRange;ILspace/kscience/kmath/structures/Buffer;)Ljava/lang/Double;
-	public fun hashCode ()I
-	public static fun hashCode-impl (Lkotlin/ranges/ClosedFloatingPointRange;)I
-	public fun nearestInDomain (Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-	public static fun nearestInDomain-impl (Lkotlin/ranges/ClosedFloatingPointRange;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-	public fun toString ()Ljava/lang/String;
-	public static fun toString-impl (Lkotlin/ranges/ClosedFloatingPointRange;)Ljava/lang/String;
-	public final synthetic fun unbox-impl ()Lkotlin/ranges/ClosedFloatingPointRange;
-	public fun volume ()D
-	public static fun volume-impl (Lkotlin/ranges/ClosedFloatingPointRange;)D
-}
-
 public abstract interface class space/kscience/kmath/expressions/AutoDiffProcessor {
 	public abstract fun process (Lkotlin/jvm/functions/Function1;)Lspace/kscience/kmath/expressions/DifferentiableExpression;
 }
@@ -179,9 +115,6 @@ public class space/kscience/kmath/expressions/FunctionalExpressionExtendedField
 	public fun cosh (Lspace/kscience/kmath/expressions/Expression;)Lspace/kscience/kmath/expressions/Expression;
 	public synthetic fun exp (Ljava/lang/Object;)Ljava/lang/Object;
 	public fun exp (Lspace/kscience/kmath/expressions/Expression;)Lspace/kscience/kmath/expressions/Expression;
-	public synthetic fun leftSideNumberOperation (Ljava/lang/String;Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun leftSideNumberOperation (Ljava/lang/String;Ljava/lang/Number;Lspace/kscience/kmath/expressions/Expression;)Lspace/kscience/kmath/expressions/Expression;
-	public fun leftSideNumberOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public synthetic fun ln (Ljava/lang/Object;)Ljava/lang/Object;
 	public fun ln (Lspace/kscience/kmath/expressions/Expression;)Lspace/kscience/kmath/expressions/Expression;
 	public synthetic fun number (Ljava/lang/Number;)Ljava/lang/Object;
@@ -190,8 +123,6 @@ public class space/kscience/kmath/expressions/FunctionalExpressionExtendedField
 	public fun pow (Lspace/kscience/kmath/expressions/Expression;Ljava/lang/Number;)Lspace/kscience/kmath/expressions/Expression;
 	public synthetic fun power (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public fun power (Lspace/kscience/kmath/expressions/Expression;Ljava/lang/Number;)Lspace/kscience/kmath/expressions/Expression;
-	public synthetic fun rightSideNumberOperation (Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
-	public fun rightSideNumberOperation (Ljava/lang/String;Lspace/kscience/kmath/expressions/Expression;Ljava/lang/Number;)Lspace/kscience/kmath/expressions/Expression;
 	public fun rightSideNumberOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public synthetic fun sin (Ljava/lang/Object;)Ljava/lang/Object;
 	public fun sin (Lspace/kscience/kmath/expressions/Expression;)Lspace/kscience/kmath/expressions/Expression;
@@ -206,17 +137,31 @@ public class space/kscience/kmath/expressions/FunctionalExpressionExtendedField
 	public fun unaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
 }
 
-public class space/kscience/kmath/expressions/FunctionalExpressionField : space/kscience/kmath/expressions/FunctionalExpressionRing, space/kscience/kmath/operations/Field {
+public class space/kscience/kmath/expressions/FunctionalExpressionField : space/kscience/kmath/expressions/FunctionalExpressionRing, space/kscience/kmath/operations/Field, space/kscience/kmath/operations/ScaleOperations {
 	public fun <init> (Lspace/kscience/kmath/operations/Field;)V
 	public fun binaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
-	public synthetic fun div (Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun div (Ljava/lang/Number;Lspace/kscience/kmath/expressions/Expression;)Lspace/kscience/kmath/expressions/Expression;
+	public synthetic fun div (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public synthetic fun div (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public final fun div (Ljava/lang/Object;Lspace/kscience/kmath/expressions/Expression;)Lspace/kscience/kmath/expressions/Expression;
+	public fun div (Lspace/kscience/kmath/expressions/Expression;Ljava/lang/Number;)Lspace/kscience/kmath/expressions/Expression;
 	public final fun div (Lspace/kscience/kmath/expressions/Expression;Ljava/lang/Object;)Lspace/kscience/kmath/expressions/Expression;
 	public fun div (Lspace/kscience/kmath/expressions/Expression;Lspace/kscience/kmath/expressions/Expression;)Lspace/kscience/kmath/expressions/Expression;
 	public synthetic fun divide (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun divide (Lspace/kscience/kmath/expressions/Expression;Lspace/kscience/kmath/expressions/Expression;)Lspace/kscience/kmath/expressions/Expression;
+	public synthetic fun leftSideNumberOperation (Ljava/lang/String;Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
+	public fun leftSideNumberOperation (Ljava/lang/String;Ljava/lang/Number;Lspace/kscience/kmath/expressions/Expression;)Lspace/kscience/kmath/expressions/Expression;
+	public fun leftSideNumberOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
+	public synthetic fun number (Ljava/lang/Number;)Ljava/lang/Object;
+	public fun number (Ljava/lang/Number;)Lspace/kscience/kmath/expressions/Expression;
+	public synthetic fun rightSideNumberOperation (Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
+	public fun rightSideNumberOperation (Ljava/lang/String;Lspace/kscience/kmath/expressions/Expression;Ljava/lang/Number;)Lspace/kscience/kmath/expressions/Expression;
+	public fun rightSideNumberOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
+	public synthetic fun scale (Ljava/lang/Object;D)Ljava/lang/Object;
+	public fun scale (Lspace/kscience/kmath/expressions/Expression;D)Lspace/kscience/kmath/expressions/Expression;
+	public synthetic fun times (Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
+	public fun times (Ljava/lang/Number;Lspace/kscience/kmath/expressions/Expression;)Lspace/kscience/kmath/expressions/Expression;
+	public synthetic fun times (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
+	public fun times (Lspace/kscience/kmath/expressions/Expression;Ljava/lang/Number;)Lspace/kscience/kmath/expressions/Expression;
 	public fun unaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
 }
 
@@ -239,24 +184,16 @@ public class space/kscience/kmath/expressions/FunctionalExpressionSpace : space/
 	public synthetic fun add (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun add (Lspace/kscience/kmath/expressions/Expression;Lspace/kscience/kmath/expressions/Expression;)Lspace/kscience/kmath/expressions/Expression;
 	public fun binaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
-	public synthetic fun div (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
-	public fun div (Lspace/kscience/kmath/expressions/Expression;Ljava/lang/Number;)Lspace/kscience/kmath/expressions/Expression;
 	public synthetic fun getZero ()Ljava/lang/Object;
 	public fun getZero ()Lspace/kscience/kmath/expressions/Expression;
 	public synthetic fun minus (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public final fun minus (Ljava/lang/Object;Lspace/kscience/kmath/expressions/Expression;)Lspace/kscience/kmath/expressions/Expression;
 	public final fun minus (Lspace/kscience/kmath/expressions/Expression;Ljava/lang/Object;)Lspace/kscience/kmath/expressions/Expression;
 	public fun minus (Lspace/kscience/kmath/expressions/Expression;Lspace/kscience/kmath/expressions/Expression;)Lspace/kscience/kmath/expressions/Expression;
-	public synthetic fun multiply (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
-	public fun multiply (Lspace/kscience/kmath/expressions/Expression;Ljava/lang/Number;)Lspace/kscience/kmath/expressions/Expression;
 	public synthetic fun plus (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public final fun plus (Ljava/lang/Object;Lspace/kscience/kmath/expressions/Expression;)Lspace/kscience/kmath/expressions/Expression;
 	public final fun plus (Lspace/kscience/kmath/expressions/Expression;Ljava/lang/Object;)Lspace/kscience/kmath/expressions/Expression;
 	public fun plus (Lspace/kscience/kmath/expressions/Expression;Lspace/kscience/kmath/expressions/Expression;)Lspace/kscience/kmath/expressions/Expression;
-	public synthetic fun times (Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun times (Ljava/lang/Number;Lspace/kscience/kmath/expressions/Expression;)Lspace/kscience/kmath/expressions/Expression;
-	public synthetic fun times (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
-	public fun times (Lspace/kscience/kmath/expressions/Expression;Ljava/lang/Number;)Lspace/kscience/kmath/expressions/Expression;
 	public synthetic fun unaryMinus (Ljava/lang/Object;)Ljava/lang/Object;
 	public fun unaryMinus (Lspace/kscience/kmath/expressions/Expression;)Lspace/kscience/kmath/expressions/Expression;
 	public fun unaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
@@ -272,7 +209,7 @@ public final class space/kscience/kmath/expressions/SimpleAutoDiffExpression : s
 	public fun invoke (Ljava/util/Map;)Ljava/lang/Object;
 }
 
-public final class space/kscience/kmath/expressions/SimpleAutoDiffExtendedField : space/kscience/kmath/expressions/SimpleAutoDiffField, space/kscience/kmath/operations/ExtendedField {
+public final class space/kscience/kmath/expressions/SimpleAutoDiffExtendedField : space/kscience/kmath/expressions/SimpleAutoDiffField, space/kscience/kmath/operations/ExtendedField, space/kscience/kmath/operations/ScaleOperations {
 	public fun <init> (Lspace/kscience/kmath/operations/ExtendedField;Ljava/util/Map;)V
 	public synthetic fun acos (Ljava/lang/Object;)Ljava/lang/Object;
 	public fun acos (Lspace/kscience/kmath/expressions/AutoDiffValue;)Lspace/kscience/kmath/expressions/AutoDiffValue;
@@ -294,12 +231,16 @@ public final class space/kscience/kmath/expressions/SimpleAutoDiffExtendedField
 	public fun exp (Lspace/kscience/kmath/expressions/AutoDiffValue;)Lspace/kscience/kmath/expressions/AutoDiffValue;
 	public synthetic fun ln (Ljava/lang/Object;)Ljava/lang/Object;
 	public fun ln (Lspace/kscience/kmath/expressions/AutoDiffValue;)Lspace/kscience/kmath/expressions/AutoDiffValue;
+	public synthetic fun number (Ljava/lang/Number;)Ljava/lang/Object;
+	public fun number (Ljava/lang/Number;)Lspace/kscience/kmath/expressions/AutoDiffValue;
 	public synthetic fun pow (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public fun pow (Lspace/kscience/kmath/expressions/AutoDiffValue;Ljava/lang/Number;)Lspace/kscience/kmath/expressions/AutoDiffValue;
 	public final fun pow (Lspace/kscience/kmath/expressions/AutoDiffValue;Lspace/kscience/kmath/expressions/AutoDiffValue;)Lspace/kscience/kmath/expressions/AutoDiffValue;
 	public synthetic fun power (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public fun power (Lspace/kscience/kmath/expressions/AutoDiffValue;Ljava/lang/Number;)Lspace/kscience/kmath/expressions/AutoDiffValue;
 	public fun rightSideNumberOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
+	public synthetic fun scale (Ljava/lang/Object;D)Ljava/lang/Object;
+	public fun scale (Lspace/kscience/kmath/expressions/AutoDiffValue;D)Lspace/kscience/kmath/expressions/AutoDiffValue;
 	public synthetic fun sin (Ljava/lang/Object;)Ljava/lang/Object;
 	public fun sin (Lspace/kscience/kmath/expressions/AutoDiffValue;)Lspace/kscience/kmath/expressions/AutoDiffValue;
 	public synthetic fun sinh (Ljava/lang/Object;)Ljava/lang/Object;
@@ -314,7 +255,7 @@ public final class space/kscience/kmath/expressions/SimpleAutoDiffExtendedField
 	public fun unaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
 }
 
-public class space/kscience/kmath/expressions/SimpleAutoDiffField : space/kscience/kmath/expressions/ExpressionAlgebra, space/kscience/kmath/operations/Field, space/kscience/kmath/operations/RingWithNumbers {
+public class space/kscience/kmath/expressions/SimpleAutoDiffField : space/kscience/kmath/expressions/ExpressionAlgebra, space/kscience/kmath/operations/Field, space/kscience/kmath/operations/NumbersAddOperations {
 	public fun <init> (Lspace/kscience/kmath/operations/Field;Ljava/util/Map;)V
 	public synthetic fun add (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun add (Lspace/kscience/kmath/expressions/AutoDiffValue;Lspace/kscience/kmath/expressions/AutoDiffValue;)Lspace/kscience/kmath/expressions/AutoDiffValue;
@@ -329,8 +270,6 @@ public class space/kscience/kmath/expressions/SimpleAutoDiffField : space/kscien
 	public fun const (Ljava/lang/Object;)Lspace/kscience/kmath/expressions/AutoDiffValue;
 	public final fun const (Lkotlin/jvm/functions/Function1;)Lspace/kscience/kmath/expressions/AutoDiffValue;
 	public final fun derive (Ljava/lang/Object;Lkotlin/jvm/functions/Function2;)Ljava/lang/Object;
-	public synthetic fun div (Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun div (Ljava/lang/Number;Lspace/kscience/kmath/expressions/AutoDiffValue;)Lspace/kscience/kmath/expressions/AutoDiffValue;
 	public synthetic fun div (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public synthetic fun div (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun div (Lspace/kscience/kmath/expressions/AutoDiffValue;Ljava/lang/Number;)Lspace/kscience/kmath/expressions/AutoDiffValue;
@@ -352,9 +291,7 @@ public class space/kscience/kmath/expressions/SimpleAutoDiffField : space/kscien
 	public synthetic fun minus (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun minus (Lspace/kscience/kmath/expressions/AutoDiffValue;Ljava/lang/Number;)Lspace/kscience/kmath/expressions/AutoDiffValue;
 	public fun minus (Lspace/kscience/kmath/expressions/AutoDiffValue;Lspace/kscience/kmath/expressions/AutoDiffValue;)Lspace/kscience/kmath/expressions/AutoDiffValue;
-	public synthetic fun multiply (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public synthetic fun multiply (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun multiply (Lspace/kscience/kmath/expressions/AutoDiffValue;Ljava/lang/Number;)Lspace/kscience/kmath/expressions/AutoDiffValue;
 	public fun multiply (Lspace/kscience/kmath/expressions/AutoDiffValue;Lspace/kscience/kmath/expressions/AutoDiffValue;)Lspace/kscience/kmath/expressions/AutoDiffValue;
 	public synthetic fun number (Ljava/lang/Number;)Ljava/lang/Object;
 	public fun number (Ljava/lang/Number;)Lspace/kscience/kmath/expressions/AutoDiffValue;
@@ -367,6 +304,8 @@ public class space/kscience/kmath/expressions/SimpleAutoDiffField : space/kscien
 	public synthetic fun rightSideNumberOperation (Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public fun rightSideNumberOperation (Ljava/lang/String;Lspace/kscience/kmath/expressions/AutoDiffValue;Ljava/lang/Number;)Lspace/kscience/kmath/expressions/AutoDiffValue;
 	public fun rightSideNumberOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
+	public synthetic fun scale (Ljava/lang/Object;D)Ljava/lang/Object;
+	public fun scale (Lspace/kscience/kmath/expressions/AutoDiffValue;D)Lspace/kscience/kmath/expressions/AutoDiffValue;
 	public final fun setD (Lspace/kscience/kmath/expressions/AutoDiffValue;Ljava/lang/Object;)V
 	public synthetic fun times (Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun times (Ljava/lang/Number;Lspace/kscience/kmath/expressions/AutoDiffValue;)Lspace/kscience/kmath/expressions/AutoDiffValue;
@@ -521,8 +460,6 @@ public final class space/kscience/kmath/linear/BufferMatrixContext : space/kscie
 	public fun binaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public synthetic fun bindSymbol (Ljava/lang/String;)Ljava/lang/Object;
 	public fun bindSymbol (Ljava/lang/String;)Lspace/kscience/kmath/nd/Structure2D;
-	public synthetic fun div (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
-	public fun div (Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Number;)Lspace/kscience/kmath/nd/Structure2D;
 	public fun dot (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/linear/BufferMatrix;
 	public synthetic fun dot (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
 	public fun dot (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
@@ -530,21 +467,14 @@ public final class space/kscience/kmath/linear/BufferMatrixContext : space/kscie
 	public synthetic fun minus (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun minus (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/linear/BufferMatrix;
 	public synthetic fun minus (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public synthetic fun multiply (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
-	public fun multiply (Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Number;)Lspace/kscience/kmath/linear/BufferMatrix;
-	public synthetic fun multiply (Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Number;)Lspace/kscience/kmath/nd/Structure2D;
 	public final fun one (II)Lspace/kscience/kmath/nd/Structure2D;
 	public synthetic fun plus (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun plus (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
 	public fun point (ILkotlin/jvm/functions/Function1;)Lspace/kscience/kmath/structures/Buffer;
 	public fun produce (IILkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/linear/BufferMatrix;
 	public synthetic fun produce (IILkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/nd/Structure2D;
-	public synthetic fun times (Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun times (Ljava/lang/Number;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public synthetic fun times (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public fun times (Ljava/lang/Object;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/linear/BufferMatrix;
 	public synthetic fun times (Ljava/lang/Object;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public fun times (Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Number;)Lspace/kscience/kmath/nd/Structure2D;
 	public fun times (Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Object;)Lspace/kscience/kmath/linear/BufferMatrix;
 	public synthetic fun times (Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Object;)Lspace/kscience/kmath/nd/Structure2D;
 	public synthetic fun unaryMinus (Ljava/lang/Object;)Ljava/lang/Object;
@@ -561,7 +491,7 @@ public final class space/kscience/kmath/linear/BufferMatrixContext$Companion {
 }
 
 public final class space/kscience/kmath/linear/BufferVectorSpace : space/kscience/kmath/linear/VectorSpace {
-	public fun <init> (ILspace/kscience/kmath/operations/Space;Lkotlin/jvm/functions/Function2;)V
+	public fun <init> (ILspace/kscience/kmath/operations/Ring;Lkotlin/jvm/functions/Function2;)V
 	public synthetic fun add (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun add (Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
 	public synthetic fun binaryOperation (Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
@@ -569,24 +499,17 @@ public final class space/kscience/kmath/linear/BufferVectorSpace : space/kscienc
 	public fun binaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public synthetic fun bindSymbol (Ljava/lang/String;)Ljava/lang/Object;
 	public fun bindSymbol (Ljava/lang/String;)Lspace/kscience/kmath/structures/Buffer;
-	public synthetic fun div (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
-	public fun div (Lspace/kscience/kmath/structures/Buffer;Ljava/lang/Number;)Lspace/kscience/kmath/structures/Buffer;
+	public fun getAlgebra ()Lspace/kscience/kmath/operations/Ring;
 	public final fun getBufferFactory ()Lkotlin/jvm/functions/Function2;
 	public fun getSize ()I
-	public fun getSpace ()Lspace/kscience/kmath/operations/Space;
 	public synthetic fun getZero ()Ljava/lang/Object;
 	public fun getZero ()Lspace/kscience/kmath/structures/Buffer;
 	public synthetic fun minus (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun minus (Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-	public synthetic fun multiply (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
-	public fun multiply (Lspace/kscience/kmath/structures/Buffer;Ljava/lang/Number;)Lspace/kscience/kmath/structures/Buffer;
 	public synthetic fun plus (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun plus (Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
 	public fun produce (Lkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/structures/Buffer;
-	public synthetic fun times (Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun times (Ljava/lang/Number;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-	public synthetic fun times (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
-	public fun times (Lspace/kscience/kmath/structures/Buffer;Ljava/lang/Number;)Lspace/kscience/kmath/structures/Buffer;
+	public fun scale (Lspace/kscience/kmath/structures/Buffer;Ljava/lang/Object;)Lspace/kscience/kmath/structures/Buffer;
 	public synthetic fun unaryMinus (Ljava/lang/Object;)Ljava/lang/Object;
 	public fun unaryMinus (Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
 	public synthetic fun unaryOperation (Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/Object;
@@ -617,7 +540,6 @@ public abstract interface class space/kscience/kmath/linear/GenericMatrixContext
 	public abstract fun dot (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
 	public abstract fun getElementContext ()Lspace/kscience/kmath/operations/Ring;
 	public abstract fun minus (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public abstract fun multiply (Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Number;)Lspace/kscience/kmath/nd/Structure2D;
 	public abstract fun times (Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Object;)Lspace/kscience/kmath/nd/Structure2D;
 	public abstract fun unaryMinus (Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
 }
@@ -627,16 +549,12 @@ public final class space/kscience/kmath/linear/GenericMatrixContext$DefaultImpls
 	public static fun binaryOperation (Lspace/kscience/kmath/linear/GenericMatrixContext;Ljava/lang/String;Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
 	public static fun binaryOperationFunction (Lspace/kscience/kmath/linear/GenericMatrixContext;Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public static fun bindSymbol (Lspace/kscience/kmath/linear/GenericMatrixContext;Ljava/lang/String;)Lspace/kscience/kmath/nd/Structure2D;
-	public static fun div (Lspace/kscience/kmath/linear/GenericMatrixContext;Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Number;)Lspace/kscience/kmath/nd/Structure2D;
 	public static fun dot (Lspace/kscience/kmath/linear/GenericMatrixContext;Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
 	public static fun dot (Lspace/kscience/kmath/linear/GenericMatrixContext;Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
 	public static fun minus (Lspace/kscience/kmath/linear/GenericMatrixContext;Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public static fun multiply (Lspace/kscience/kmath/linear/GenericMatrixContext;Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Number;)Lspace/kscience/kmath/nd/Structure2D;
 	public static fun plus (Lspace/kscience/kmath/linear/GenericMatrixContext;Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
 	public static fun point (Lspace/kscience/kmath/linear/GenericMatrixContext;ILkotlin/jvm/functions/Function1;)Lspace/kscience/kmath/structures/Buffer;
-	public static fun times (Lspace/kscience/kmath/linear/GenericMatrixContext;Ljava/lang/Number;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
 	public static fun times (Lspace/kscience/kmath/linear/GenericMatrixContext;Ljava/lang/Object;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public static fun times (Lspace/kscience/kmath/linear/GenericMatrixContext;Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Number;)Lspace/kscience/kmath/nd/Structure2D;
 	public static fun times (Lspace/kscience/kmath/linear/GenericMatrixContext;Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Object;)Lspace/kscience/kmath/nd/Structure2D;
 	public static fun unaryMinus (Lspace/kscience/kmath/linear/GenericMatrixContext;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
 	public static fun unaryOperation (Lspace/kscience/kmath/linear/GenericMatrixContext;Ljava/lang/String;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
@@ -727,14 +645,10 @@ public final class space/kscience/kmath/linear/MatrixContext$DefaultImpls {
 	public static fun binaryOperation (Lspace/kscience/kmath/linear/MatrixContext;Ljava/lang/String;Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
 	public static fun binaryOperationFunction (Lspace/kscience/kmath/linear/MatrixContext;Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public static fun bindSymbol (Lspace/kscience/kmath/linear/MatrixContext;Ljava/lang/String;)Lspace/kscience/kmath/nd/Structure2D;
-	public static fun div (Lspace/kscience/kmath/linear/MatrixContext;Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Number;)Lspace/kscience/kmath/nd/Structure2D;
 	public static fun minus (Lspace/kscience/kmath/linear/MatrixContext;Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
 	public static fun plus (Lspace/kscience/kmath/linear/MatrixContext;Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
 	public static fun point (Lspace/kscience/kmath/linear/MatrixContext;ILkotlin/jvm/functions/Function1;)Lspace/kscience/kmath/structures/Buffer;
-	public static fun times (Lspace/kscience/kmath/linear/MatrixContext;Ljava/lang/Number;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
 	public static fun times (Lspace/kscience/kmath/linear/MatrixContext;Ljava/lang/Object;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public static fun times (Lspace/kscience/kmath/linear/MatrixContext;Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Number;)Lspace/kscience/kmath/nd/Structure2D;
-	public static fun unaryMinus (Lspace/kscience/kmath/linear/MatrixContext;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
 	public static fun unaryOperation (Lspace/kscience/kmath/linear/MatrixContext;Ljava/lang/String;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
 	public static fun unaryOperationFunction (Lspace/kscience/kmath/linear/MatrixContext;Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
 	public static fun unaryPlus (Lspace/kscience/kmath/linear/MatrixContext;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
@@ -792,15 +706,11 @@ public final class space/kscience/kmath/linear/RealMatrixContext : space/kscienc
 	public fun binaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public synthetic fun bindSymbol (Ljava/lang/String;)Ljava/lang/Object;
 	public fun bindSymbol (Ljava/lang/String;)Lspace/kscience/kmath/nd/Structure2D;
-	public synthetic fun div (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
-	public fun div (Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Number;)Lspace/kscience/kmath/nd/Structure2D;
 	public fun dot (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/linear/BufferMatrix;
 	public synthetic fun dot (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
 	public fun dot (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
 	public synthetic fun minus (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun minus (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public synthetic fun multiply (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
-	public fun multiply (Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Number;)Lspace/kscience/kmath/linear/BufferMatrix;
 	public final fun one (II)Lspace/kscience/kmath/nd/Structure2D;
 	public synthetic fun plus (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun plus (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
@@ -808,12 +718,8 @@ public final class space/kscience/kmath/linear/RealMatrixContext : space/kscienc
 	public fun produce (IILkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/linear/BufferMatrix;
 	public synthetic fun produce (IILkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/nd/Structure2D;
 	public fun times (DLspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/linear/BufferMatrix;
-	public synthetic fun times (Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun times (Ljava/lang/Number;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public synthetic fun times (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public synthetic fun times (Ljava/lang/Object;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
 	public fun times (Lspace/kscience/kmath/nd/Structure2D;D)Lspace/kscience/kmath/linear/BufferMatrix;
-	public fun times (Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Number;)Lspace/kscience/kmath/nd/Structure2D;
 	public synthetic fun times (Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Object;)Lspace/kscience/kmath/nd/Structure2D;
 	public final fun toBufferMatrix (Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/linear/BufferMatrix;
 	public synthetic fun unaryMinus (Ljava/lang/Object;)Ljava/lang/Object;
@@ -852,16 +758,17 @@ public final class space/kscience/kmath/linear/UnitFeature : space/kscience/kmat
 public abstract interface class space/kscience/kmath/linear/VectorSpace : space/kscience/kmath/operations/Space {
 	public static final field Companion Lspace/kscience/kmath/linear/VectorSpace$Companion;
 	public abstract fun add (Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
+	public abstract fun getAlgebra ()Lspace/kscience/kmath/operations/Ring;
 	public abstract fun getSize ()I
-	public abstract fun getSpace ()Lspace/kscience/kmath/operations/Space;
 	public abstract fun getZero ()Lspace/kscience/kmath/structures/Buffer;
-	public abstract fun multiply (Lspace/kscience/kmath/structures/Buffer;Ljava/lang/Number;)Lspace/kscience/kmath/structures/Buffer;
 	public abstract fun produce (Lkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/structures/Buffer;
+	public abstract fun scale (Lspace/kscience/kmath/structures/Buffer;Ljava/lang/Object;)Lspace/kscience/kmath/structures/Buffer;
+	public abstract fun unaryMinus (Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
 }
 
 public final class space/kscience/kmath/linear/VectorSpace$Companion {
-	public final fun buffered (ILspace/kscience/kmath/operations/Space;Lkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/linear/BufferVectorSpace;
-	public static synthetic fun buffered$default (Lspace/kscience/kmath/linear/VectorSpace$Companion;ILspace/kscience/kmath/operations/Space;Lkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lspace/kscience/kmath/linear/BufferVectorSpace;
+	public final fun buffered (ILspace/kscience/kmath/operations/Ring;Lkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/linear/BufferVectorSpace;
+	public static synthetic fun buffered$default (Lspace/kscience/kmath/linear/VectorSpace$Companion;ILspace/kscience/kmath/operations/Ring;Lkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lspace/kscience/kmath/linear/BufferVectorSpace;
 	public final fun real (I)Lspace/kscience/kmath/linear/BufferVectorSpace;
 }
 
@@ -870,13 +777,10 @@ public final class space/kscience/kmath/linear/VectorSpace$DefaultImpls {
 	public static fun binaryOperation (Lspace/kscience/kmath/linear/VectorSpace;Ljava/lang/String;Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
 	public static fun binaryOperationFunction (Lspace/kscience/kmath/linear/VectorSpace;Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public static fun bindSymbol (Lspace/kscience/kmath/linear/VectorSpace;Ljava/lang/String;)Lspace/kscience/kmath/structures/Buffer;
-	public static fun div (Lspace/kscience/kmath/linear/VectorSpace;Lspace/kscience/kmath/structures/Buffer;Ljava/lang/Number;)Lspace/kscience/kmath/structures/Buffer;
 	public static fun getZero (Lspace/kscience/kmath/linear/VectorSpace;)Lspace/kscience/kmath/structures/Buffer;
 	public static fun minus (Lspace/kscience/kmath/linear/VectorSpace;Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-	public static fun multiply (Lspace/kscience/kmath/linear/VectorSpace;Lspace/kscience/kmath/structures/Buffer;Ljava/lang/Number;)Lspace/kscience/kmath/structures/Buffer;
 	public static fun plus (Lspace/kscience/kmath/linear/VectorSpace;Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-	public static fun times (Lspace/kscience/kmath/linear/VectorSpace;Ljava/lang/Number;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-	public static fun times (Lspace/kscience/kmath/linear/VectorSpace;Lspace/kscience/kmath/structures/Buffer;Ljava/lang/Number;)Lspace/kscience/kmath/structures/Buffer;
+	public static fun scale (Lspace/kscience/kmath/linear/VectorSpace;Lspace/kscience/kmath/structures/Buffer;Ljava/lang/Object;)Lspace/kscience/kmath/structures/Buffer;
 	public static fun unaryMinus (Lspace/kscience/kmath/linear/VectorSpace;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
 	public static fun unaryOperation (Lspace/kscience/kmath/linear/VectorSpace;Ljava/lang/String;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
 	public static fun unaryOperationFunction (Lspace/kscience/kmath/linear/VectorSpace;Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
@@ -956,14 +860,28 @@ public final class space/kscience/kmath/nd/BufferNDAlgebraKt {
 public class space/kscience/kmath/nd/BufferedNDField : space/kscience/kmath/nd/BufferedNDRing, space/kscience/kmath/nd/NDField {
 	public fun <init> ([ILspace/kscience/kmath/operations/Field;Lkotlin/jvm/functions/Function2;)V
 	public fun binaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
-	public synthetic fun div (Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun div (Ljava/lang/Number;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
+	public synthetic fun div (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public synthetic fun div (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun div (Ljava/lang/Object;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
+	public fun div (Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Number;)Lspace/kscience/kmath/nd/NDStructure;
 	public fun div (Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Object;)Lspace/kscience/kmath/nd/NDStructure;
 	public fun div (Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 	public synthetic fun divide (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun divide (Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
+	public synthetic fun leftSideNumberOperation (Ljava/lang/String;Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
+	public fun leftSideNumberOperation (Ljava/lang/String;Ljava/lang/Number;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
+	public fun leftSideNumberOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
+	public synthetic fun number (Ljava/lang/Number;)Ljava/lang/Object;
+	public fun number (Ljava/lang/Number;)Lspace/kscience/kmath/nd/NDStructure;
+	public synthetic fun rightSideNumberOperation (Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
+	public fun rightSideNumberOperation (Ljava/lang/String;Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Number;)Lspace/kscience/kmath/nd/NDStructure;
+	public fun rightSideNumberOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
+	public synthetic fun scale (Ljava/lang/Object;D)Ljava/lang/Object;
+	public fun scale (Lspace/kscience/kmath/nd/NDStructure;D)Lspace/kscience/kmath/nd/NDStructure;
+	public synthetic fun times (Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
+	public fun times (Ljava/lang/Number;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
+	public synthetic fun times (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
+	public fun times (Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Number;)Lspace/kscience/kmath/nd/NDStructure;
 }
 
 public class space/kscience/kmath/nd/BufferedNDRing : space/kscience/kmath/nd/BufferedNDSpace, space/kscience/kmath/nd/NDRing {
@@ -990,11 +908,9 @@ public class space/kscience/kmath/nd/BufferedNDSpace : space/kscience/kmath/nd/B
 	public fun bindSymbol (Ljava/lang/String;)Lspace/kscience/kmath/nd/NDStructure;
 	public fun combine (Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;Lkotlin/jvm/functions/Function3;)Lspace/kscience/kmath/nd/NDBuffer;
 	public synthetic fun combine (Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;Lkotlin/jvm/functions/Function3;)Lspace/kscience/kmath/nd/NDStructure;
-	public synthetic fun div (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
-	public fun div (Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Number;)Lspace/kscience/kmath/nd/NDStructure;
 	public fun getBuffer (Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/structures/Buffer;
 	public final fun getBufferFactory ()Lkotlin/jvm/functions/Function2;
-	public synthetic fun getElementContext ()Ljava/lang/Object;
+	public synthetic fun getElementContext ()Lspace/kscience/kmath/operations/Algebra;
 	public final fun getElementContext ()Lspace/kscience/kmath/operations/Space;
 	public final fun getShape ()[I
 	public fun getStrides ()Lspace/kscience/kmath/nd/Strides;
@@ -1009,18 +925,12 @@ public class space/kscience/kmath/nd/BufferedNDSpace : space/kscience/kmath/nd/B
 	public fun minus (Ljava/lang/Object;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 	public fun minus (Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Object;)Lspace/kscience/kmath/nd/NDStructure;
 	public fun minus (Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
-	public synthetic fun multiply (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
-	public fun multiply (Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Number;)Lspace/kscience/kmath/nd/NDStructure;
 	public synthetic fun plus (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun plus (Ljava/lang/Object;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 	public fun plus (Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Object;)Lspace/kscience/kmath/nd/NDStructure;
 	public fun plus (Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 	public fun produce (Lkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/nd/NDBuffer;
 	public synthetic fun produce (Lkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/nd/NDStructure;
-	public synthetic fun times (Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun times (Ljava/lang/Number;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
-	public synthetic fun times (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
-	public fun times (Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Number;)Lspace/kscience/kmath/nd/NDStructure;
 	public synthetic fun unaryMinus (Ljava/lang/Object;)Ljava/lang/Object;
 	public fun unaryMinus (Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 	public synthetic fun unaryOperation (Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/Object;
@@ -1065,7 +975,7 @@ public final class space/kscience/kmath/nd/MutableNDStructure$DefaultImpls {
 public abstract interface class space/kscience/kmath/nd/NDAlgebra {
 	public static final field Companion Lspace/kscience/kmath/nd/NDAlgebra$Companion;
 	public abstract fun combine (Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;Lkotlin/jvm/functions/Function3;)Lspace/kscience/kmath/nd/NDStructure;
-	public abstract fun getElementContext ()Ljava/lang/Object;
+	public abstract fun getElementContext ()Lspace/kscience/kmath/operations/Algebra;
 	public abstract fun getShape ()[I
 	public abstract fun invoke (Lkotlin/jvm/functions/Function1;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 	public abstract fun map (Lspace/kscience/kmath/nd/NDStructure;Lkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/nd/NDStructure;
@@ -1093,7 +1003,7 @@ public class space/kscience/kmath/nd/NDBuffer : space/kscience/kmath/nd/NDStruct
 	public fun toString ()Ljava/lang/String;
 }
 
-public abstract interface class space/kscience/kmath/nd/NDField : space/kscience/kmath/nd/NDRing, space/kscience/kmath/operations/Field {
+public abstract interface class space/kscience/kmath/nd/NDField : space/kscience/kmath/nd/NDRing, space/kscience/kmath/operations/Field, space/kscience/kmath/operations/ScaleOperations {
 	public abstract fun div (Ljava/lang/Object;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 	public abstract fun div (Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Object;)Lspace/kscience/kmath/nd/NDStructure;
 	public abstract fun divide (Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
@@ -1104,27 +1014,29 @@ public final class space/kscience/kmath/nd/NDField$DefaultImpls {
 	public static fun binaryOperation (Lspace/kscience/kmath/nd/NDField;Ljava/lang/String;Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun binaryOperationFunction (Lspace/kscience/kmath/nd/NDField;Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public static fun bindSymbol (Lspace/kscience/kmath/nd/NDField;Ljava/lang/String;)Lspace/kscience/kmath/nd/NDStructure;
-	public static fun div (Lspace/kscience/kmath/nd/NDField;Ljava/lang/Number;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun div (Lspace/kscience/kmath/nd/NDField;Ljava/lang/Object;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun div (Lspace/kscience/kmath/nd/NDField;Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Number;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun div (Lspace/kscience/kmath/nd/NDField;Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Object;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun div (Lspace/kscience/kmath/nd/NDField;Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun divide (Lspace/kscience/kmath/nd/NDField;Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun invoke (Lspace/kscience/kmath/nd/NDField;Lkotlin/jvm/functions/Function1;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
+	public static fun leftSideNumberOperation (Lspace/kscience/kmath/nd/NDField;Ljava/lang/String;Ljava/lang/Number;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
+	public static fun leftSideNumberOperationFunction (Lspace/kscience/kmath/nd/NDField;Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public static fun minus (Lspace/kscience/kmath/nd/NDField;Ljava/lang/Object;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun minus (Lspace/kscience/kmath/nd/NDField;Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Object;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun minus (Lspace/kscience/kmath/nd/NDField;Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
-	public static fun multiply (Lspace/kscience/kmath/nd/NDField;Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Number;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun multiply (Lspace/kscience/kmath/nd/NDField;Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
+	public static fun number (Lspace/kscience/kmath/nd/NDField;Ljava/lang/Number;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun plus (Lspace/kscience/kmath/nd/NDField;Ljava/lang/Object;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun plus (Lspace/kscience/kmath/nd/NDField;Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Object;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun plus (Lspace/kscience/kmath/nd/NDField;Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
+	public static fun rightSideNumberOperation (Lspace/kscience/kmath/nd/NDField;Ljava/lang/String;Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Number;)Lspace/kscience/kmath/nd/NDStructure;
+	public static fun rightSideNumberOperationFunction (Lspace/kscience/kmath/nd/NDField;Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public static fun times (Lspace/kscience/kmath/nd/NDField;Ljava/lang/Number;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun times (Lspace/kscience/kmath/nd/NDField;Ljava/lang/Object;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun times (Lspace/kscience/kmath/nd/NDField;Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Number;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun times (Lspace/kscience/kmath/nd/NDField;Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Object;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun times (Lspace/kscience/kmath/nd/NDField;Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
-	public static fun unaryMinus (Lspace/kscience/kmath/nd/NDField;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun unaryOperation (Lspace/kscience/kmath/nd/NDField;Ljava/lang/String;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun unaryOperationFunction (Lspace/kscience/kmath/nd/NDField;Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
 	public static fun unaryPlus (Lspace/kscience/kmath/nd/NDField;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
@@ -1145,22 +1057,17 @@ public final class space/kscience/kmath/nd/NDRing$DefaultImpls {
 	public static fun binaryOperation (Lspace/kscience/kmath/nd/NDRing;Ljava/lang/String;Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun binaryOperationFunction (Lspace/kscience/kmath/nd/NDRing;Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public static fun bindSymbol (Lspace/kscience/kmath/nd/NDRing;Ljava/lang/String;)Lspace/kscience/kmath/nd/NDStructure;
-	public static fun div (Lspace/kscience/kmath/nd/NDRing;Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Number;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun invoke (Lspace/kscience/kmath/nd/NDRing;Lkotlin/jvm/functions/Function1;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun minus (Lspace/kscience/kmath/nd/NDRing;Ljava/lang/Object;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun minus (Lspace/kscience/kmath/nd/NDRing;Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Object;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun minus (Lspace/kscience/kmath/nd/NDRing;Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
-	public static fun multiply (Lspace/kscience/kmath/nd/NDRing;Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Number;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun multiply (Lspace/kscience/kmath/nd/NDRing;Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun plus (Lspace/kscience/kmath/nd/NDRing;Ljava/lang/Object;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun plus (Lspace/kscience/kmath/nd/NDRing;Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Object;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun plus (Lspace/kscience/kmath/nd/NDRing;Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
-	public static fun times (Lspace/kscience/kmath/nd/NDRing;Ljava/lang/Number;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun times (Lspace/kscience/kmath/nd/NDRing;Ljava/lang/Object;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
-	public static fun times (Lspace/kscience/kmath/nd/NDRing;Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Number;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun times (Lspace/kscience/kmath/nd/NDRing;Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Object;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun times (Lspace/kscience/kmath/nd/NDRing;Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
-	public static fun unaryMinus (Lspace/kscience/kmath/nd/NDRing;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun unaryOperation (Lspace/kscience/kmath/nd/NDRing;Ljava/lang/String;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun unaryOperationFunction (Lspace/kscience/kmath/nd/NDRing;Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
 	public static fun unaryPlus (Lspace/kscience/kmath/nd/NDRing;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
@@ -1171,7 +1078,6 @@ public abstract interface class space/kscience/kmath/nd/NDSpace : space/kscience
 	public abstract fun add (Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 	public abstract fun minus (Ljava/lang/Object;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 	public abstract fun minus (Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Object;)Lspace/kscience/kmath/nd/NDStructure;
-	public abstract fun multiply (Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Number;)Lspace/kscience/kmath/nd/NDStructure;
 	public abstract fun plus (Ljava/lang/Object;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 	public abstract fun plus (Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Object;)Lspace/kscience/kmath/nd/NDStructure;
 }
@@ -1184,18 +1090,13 @@ public final class space/kscience/kmath/nd/NDSpace$DefaultImpls {
 	public static fun binaryOperation (Lspace/kscience/kmath/nd/NDSpace;Ljava/lang/String;Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun binaryOperationFunction (Lspace/kscience/kmath/nd/NDSpace;Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public static fun bindSymbol (Lspace/kscience/kmath/nd/NDSpace;Ljava/lang/String;)Lspace/kscience/kmath/nd/NDStructure;
-	public static fun div (Lspace/kscience/kmath/nd/NDSpace;Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Number;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun invoke (Lspace/kscience/kmath/nd/NDSpace;Lkotlin/jvm/functions/Function1;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun minus (Lspace/kscience/kmath/nd/NDSpace;Ljava/lang/Object;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun minus (Lspace/kscience/kmath/nd/NDSpace;Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Object;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun minus (Lspace/kscience/kmath/nd/NDSpace;Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
-	public static fun multiply (Lspace/kscience/kmath/nd/NDSpace;Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Number;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun plus (Lspace/kscience/kmath/nd/NDSpace;Ljava/lang/Object;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun plus (Lspace/kscience/kmath/nd/NDSpace;Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Object;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun plus (Lspace/kscience/kmath/nd/NDSpace;Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
-	public static fun times (Lspace/kscience/kmath/nd/NDSpace;Ljava/lang/Number;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
-	public static fun times (Lspace/kscience/kmath/nd/NDSpace;Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Number;)Lspace/kscience/kmath/nd/NDStructure;
-	public static fun unaryMinus (Lspace/kscience/kmath/nd/NDSpace;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun unaryOperation (Lspace/kscience/kmath/nd/NDSpace;Ljava/lang/String;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 	public static fun unaryOperationFunction (Lspace/kscience/kmath/nd/NDSpace;Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
 	public static fun unaryPlus (Lspace/kscience/kmath/nd/NDSpace;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
@@ -1230,7 +1131,7 @@ public final class space/kscience/kmath/nd/NDStructureKt {
 	public static final fun mapInPlace (Lspace/kscience/kmath/nd/MutableNDStructure;Lkotlin/jvm/functions/Function2;)V
 }
 
-public final class space/kscience/kmath/nd/RealNDField : space/kscience/kmath/nd/BufferedNDField, space/kscience/kmath/operations/ExtendedField, space/kscience/kmath/operations/RingWithNumbers {
+public final class space/kscience/kmath/nd/RealNDField : space/kscience/kmath/nd/BufferedNDField, space/kscience/kmath/operations/ExtendedField, space/kscience/kmath/operations/NumbersAddOperations, space/kscience/kmath/operations/ScaleOperations {
 	public fun <init> ([I)V
 	public synthetic fun acos (Ljava/lang/Object;)Ljava/lang/Object;
 	public fun acos (Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDBuffer;
@@ -1258,9 +1159,6 @@ public final class space/kscience/kmath/nd/RealNDField : space/kscience/kmath/nd
 	public fun getOne ()Lspace/kscience/kmath/nd/NDBuffer;
 	public synthetic fun getZero ()Ljava/lang/Object;
 	public fun getZero ()Lspace/kscience/kmath/nd/NDBuffer;
-	public synthetic fun leftSideNumberOperation (Ljava/lang/String;Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun leftSideNumberOperation (Ljava/lang/String;Ljava/lang/Number;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
-	public fun leftSideNumberOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public synthetic fun ln (Ljava/lang/Object;)Ljava/lang/Object;
 	public fun ln (Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDBuffer;
 	public fun map (Lspace/kscience/kmath/nd/NDStructure;Lkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/nd/NDBuffer;
@@ -1273,6 +1171,7 @@ public final class space/kscience/kmath/nd/RealNDField : space/kscience/kmath/nd
 	public fun minus (Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Number;)Lspace/kscience/kmath/nd/NDStructure;
 	public synthetic fun number (Ljava/lang/Number;)Ljava/lang/Object;
 	public fun number (Ljava/lang/Number;)Lspace/kscience/kmath/nd/NDBuffer;
+	public synthetic fun number (Ljava/lang/Number;)Lspace/kscience/kmath/nd/NDStructure;
 	public synthetic fun plus (Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun plus (Ljava/lang/Number;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 	public synthetic fun plus (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
@@ -1283,9 +1182,9 @@ public final class space/kscience/kmath/nd/RealNDField : space/kscience/kmath/nd
 	public fun power (Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Number;)Lspace/kscience/kmath/nd/NDBuffer;
 	public fun produce (Lkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/nd/NDBuffer;
 	public synthetic fun produce (Lkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/nd/NDStructure;
-	public synthetic fun rightSideNumberOperation (Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
-	public fun rightSideNumberOperation (Ljava/lang/String;Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Number;)Lspace/kscience/kmath/nd/NDStructure;
 	public fun rightSideNumberOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
+	public synthetic fun scale (Ljava/lang/Object;D)Ljava/lang/Object;
+	public fun scale (Lspace/kscience/kmath/nd/NDStructure;D)Lspace/kscience/kmath/nd/NDStructure;
 	public synthetic fun sin (Ljava/lang/Object;)Ljava/lang/Object;
 	public fun sin (Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDBuffer;
 	public synthetic fun sinh (Ljava/lang/Object;)Ljava/lang/Object;
@@ -1310,7 +1209,7 @@ public final class space/kscience/kmath/nd/ShapeMismatchException : java/lang/Ru
 	public final fun getExpected ()[I
 }
 
-public final class space/kscience/kmath/nd/ShortNDRing : space/kscience/kmath/nd/BufferedNDRing, space/kscience/kmath/operations/RingWithNumbers {
+public final class space/kscience/kmath/nd/ShortNDRing : space/kscience/kmath/nd/BufferedNDRing, space/kscience/kmath/operations/NumbersAddOperations {
 	public fun <init> ([I)V
 	public synthetic fun getOne ()Ljava/lang/Object;
 	public fun getOne ()Lspace/kscience/kmath/nd/NDBuffer;
@@ -1420,12 +1319,8 @@ public abstract interface class space/kscience/kmath/operations/AlgebraElement {
 }
 
 public final class space/kscience/kmath/operations/AlgebraElementsKt {
-	public static final fun div (Lspace/kscience/kmath/operations/AlgebraElement;Ljava/lang/Number;)Lspace/kscience/kmath/operations/AlgebraElement;
 	public static final fun div (Lspace/kscience/kmath/operations/AlgebraElement;Lspace/kscience/kmath/operations/AlgebraElement;)Lspace/kscience/kmath/operations/AlgebraElement;
-	public static final fun minus (Lspace/kscience/kmath/operations/AlgebraElement;Lspace/kscience/kmath/operations/AlgebraElement;)Lspace/kscience/kmath/operations/AlgebraElement;
 	public static final fun plus (Lspace/kscience/kmath/operations/AlgebraElement;Lspace/kscience/kmath/operations/AlgebraElement;)Lspace/kscience/kmath/operations/AlgebraElement;
-	public static final fun times (Ljava/lang/Number;Lspace/kscience/kmath/operations/AlgebraElement;)Lspace/kscience/kmath/operations/AlgebraElement;
-	public static final fun times (Lspace/kscience/kmath/operations/AlgebraElement;Ljava/lang/Number;)Lspace/kscience/kmath/operations/AlgebraElement;
 	public static final fun times (Lspace/kscience/kmath/operations/AlgebraElement;Lspace/kscience/kmath/operations/AlgebraElement;)Lspace/kscience/kmath/operations/AlgebraElement;
 }
 
@@ -1481,7 +1376,7 @@ public final class space/kscience/kmath/operations/BigInt$Companion {
 	public final fun getZERO ()Lspace/kscience/kmath/operations/BigInt;
 }
 
-public final class space/kscience/kmath/operations/BigIntField : space/kscience/kmath/operations/Field, space/kscience/kmath/operations/RingWithNumbers {
+public final class space/kscience/kmath/operations/BigIntField : space/kscience/kmath/operations/Field, space/kscience/kmath/operations/NumbersAddOperations, space/kscience/kmath/operations/ScaleOperations {
 	public static final field INSTANCE Lspace/kscience/kmath/operations/BigIntField;
 	public synthetic fun add (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun add (Lspace/kscience/kmath/operations/BigInt;Lspace/kscience/kmath/operations/BigInt;)Lspace/kscience/kmath/operations/BigInt;
@@ -1490,8 +1385,6 @@ public final class space/kscience/kmath/operations/BigIntField : space/kscience/
 	public fun binaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public synthetic fun bindSymbol (Ljava/lang/String;)Ljava/lang/Object;
 	public fun bindSymbol (Ljava/lang/String;)Lspace/kscience/kmath/operations/BigInt;
-	public synthetic fun div (Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun div (Ljava/lang/Number;Lspace/kscience/kmath/operations/BigInt;)Lspace/kscience/kmath/operations/BigInt;
 	public synthetic fun div (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public synthetic fun div (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun div (Lspace/kscience/kmath/operations/BigInt;Ljava/lang/Number;)Lspace/kscience/kmath/operations/BigInt;
@@ -1511,9 +1404,7 @@ public final class space/kscience/kmath/operations/BigIntField : space/kscience/
 	public synthetic fun minus (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun minus (Lspace/kscience/kmath/operations/BigInt;Ljava/lang/Number;)Lspace/kscience/kmath/operations/BigInt;
 	public fun minus (Lspace/kscience/kmath/operations/BigInt;Lspace/kscience/kmath/operations/BigInt;)Lspace/kscience/kmath/operations/BigInt;
-	public synthetic fun multiply (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public synthetic fun multiply (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun multiply (Lspace/kscience/kmath/operations/BigInt;Ljava/lang/Number;)Lspace/kscience/kmath/operations/BigInt;
 	public fun multiply (Lspace/kscience/kmath/operations/BigInt;Lspace/kscience/kmath/operations/BigInt;)Lspace/kscience/kmath/operations/BigInt;
 	public synthetic fun number (Ljava/lang/Number;)Ljava/lang/Object;
 	public fun number (Ljava/lang/Number;)Lspace/kscience/kmath/operations/BigInt;
@@ -1526,6 +1417,8 @@ public final class space/kscience/kmath/operations/BigIntField : space/kscience/
 	public synthetic fun rightSideNumberOperation (Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public fun rightSideNumberOperation (Ljava/lang/String;Lspace/kscience/kmath/operations/BigInt;Ljava/lang/Number;)Lspace/kscience/kmath/operations/BigInt;
 	public fun rightSideNumberOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
+	public synthetic fun scale (Ljava/lang/Object;D)Ljava/lang/Object;
+	public fun scale (Lspace/kscience/kmath/operations/BigInt;D)Lspace/kscience/kmath/operations/BigInt;
 	public synthetic fun times (Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun times (Ljava/lang/Number;Lspace/kscience/kmath/operations/BigInt;)Lspace/kscience/kmath/operations/BigInt;
 	public synthetic fun times (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
@@ -1565,8 +1458,6 @@ public final class space/kscience/kmath/operations/ByteRing : space/kscience/kma
 	public fun binaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public fun bindSymbol (Ljava/lang/String;)Ljava/lang/Byte;
 	public synthetic fun bindSymbol (Ljava/lang/String;)Ljava/lang/Object;
-	public fun div (BLjava/lang/Number;)Ljava/lang/Byte;
-	public synthetic fun div (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public fun getOne ()Ljava/lang/Byte;
 	public synthetic fun getOne ()Ljava/lang/Object;
 	public fun getZero ()Ljava/lang/Byte;
@@ -1577,8 +1468,6 @@ public final class space/kscience/kmath/operations/ByteRing : space/kscience/kma
 	public fun minus (BB)Ljava/lang/Byte;
 	public synthetic fun minus (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun multiply (BB)Ljava/lang/Byte;
-	public fun multiply (BLjava/lang/Number;)Ljava/lang/Byte;
-	public synthetic fun multiply (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public synthetic fun multiply (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun norm (B)Ljava/lang/Byte;
 	public synthetic fun norm (Ljava/lang/Object;)Ljava/lang/Object;
@@ -1590,10 +1479,6 @@ public final class space/kscience/kmath/operations/ByteRing : space/kscience/kma
 	public synthetic fun rightSideNumberOperation (Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public fun rightSideNumberOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public fun times (BB)Ljava/lang/Byte;
-	public fun times (BLjava/lang/Number;)Ljava/lang/Byte;
-	public fun times (Ljava/lang/Number;B)Ljava/lang/Byte;
-	public synthetic fun times (Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
-	public synthetic fun times (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public synthetic fun times (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun unaryMinus (B)Ljava/lang/Byte;
 	public synthetic fun unaryMinus (Ljava/lang/Object;)Ljava/lang/Object;
@@ -1605,16 +1490,34 @@ public final class space/kscience/kmath/operations/ByteRing : space/kscience/kma
 }
 
 public abstract interface class space/kscience/kmath/operations/ExponentialOperations : space/kscience/kmath/operations/Algebra {
+	public static final field ACOSH_OPERATION Ljava/lang/String;
+	public static final field ASINH_OPERATION Ljava/lang/String;
+	public static final field ATANH_OPERATION Ljava/lang/String;
+	public static final field COSH_OPERATION Ljava/lang/String;
 	public static final field Companion Lspace/kscience/kmath/operations/ExponentialOperations$Companion;
 	public static final field EXP_OPERATION Ljava/lang/String;
 	public static final field LN_OPERATION Ljava/lang/String;
+	public static final field SINH_OPERATION Ljava/lang/String;
+	public static final field TANH_OPERATION Ljava/lang/String;
+	public abstract fun acosh (Ljava/lang/Object;)Ljava/lang/Object;
+	public abstract fun asinh (Ljava/lang/Object;)Ljava/lang/Object;
+	public abstract fun atanh (Ljava/lang/Object;)Ljava/lang/Object;
+	public abstract fun cosh (Ljava/lang/Object;)Ljava/lang/Object;
 	public abstract fun exp (Ljava/lang/Object;)Ljava/lang/Object;
 	public abstract fun ln (Ljava/lang/Object;)Ljava/lang/Object;
+	public abstract fun sinh (Ljava/lang/Object;)Ljava/lang/Object;
+	public abstract fun tanh (Ljava/lang/Object;)Ljava/lang/Object;
 }
 
 public final class space/kscience/kmath/operations/ExponentialOperations$Companion {
+	public static final field ACOSH_OPERATION Ljava/lang/String;
+	public static final field ASINH_OPERATION Ljava/lang/String;
+	public static final field ATANH_OPERATION Ljava/lang/String;
+	public static final field COSH_OPERATION Ljava/lang/String;
 	public static final field EXP_OPERATION Ljava/lang/String;
 	public static final field LN_OPERATION Ljava/lang/String;
+	public static final field SINH_OPERATION Ljava/lang/String;
+	public static final field TANH_OPERATION Ljava/lang/String;
 }
 
 public final class space/kscience/kmath/operations/ExponentialOperations$DefaultImpls {
@@ -1625,7 +1528,7 @@ public final class space/kscience/kmath/operations/ExponentialOperations$Default
 	public static fun unaryOperationFunction (Lspace/kscience/kmath/operations/ExponentialOperations;Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
 }
 
-public abstract interface class space/kscience/kmath/operations/ExtendedField : space/kscience/kmath/operations/ExtendedFieldOperations, space/kscience/kmath/operations/Field, space/kscience/kmath/operations/NumericAlgebra {
+public abstract interface class space/kscience/kmath/operations/ExtendedField : space/kscience/kmath/operations/ExtendedFieldOperations, space/kscience/kmath/operations/Field, space/kscience/kmath/operations/NumericAlgebra, space/kscience/kmath/operations/ScaleOperations {
 	public abstract fun acosh (Ljava/lang/Object;)Ljava/lang/Object;
 	public abstract fun asinh (Ljava/lang/Object;)Ljava/lang/Object;
 	public abstract fun atanh (Ljava/lang/Object;)Ljava/lang/Object;
@@ -1643,12 +1546,12 @@ public final class space/kscience/kmath/operations/ExtendedField$DefaultImpls {
 	public static fun binaryOperationFunction (Lspace/kscience/kmath/operations/ExtendedField;Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public static fun bindSymbol (Lspace/kscience/kmath/operations/ExtendedField;Ljava/lang/String;)Ljava/lang/Object;
 	public static fun cosh (Lspace/kscience/kmath/operations/ExtendedField;Ljava/lang/Object;)Ljava/lang/Object;
-	public static fun div (Lspace/kscience/kmath/operations/ExtendedField;Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
 	public static fun div (Lspace/kscience/kmath/operations/ExtendedField;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public static fun div (Lspace/kscience/kmath/operations/ExtendedField;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public static fun leftSideNumberOperation (Lspace/kscience/kmath/operations/ExtendedField;Ljava/lang/String;Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
 	public static fun leftSideNumberOperationFunction (Lspace/kscience/kmath/operations/ExtendedField;Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public static fun minus (Lspace/kscience/kmath/operations/ExtendedField;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+	public static fun number (Lspace/kscience/kmath/operations/ExtendedField;Ljava/lang/Number;)Ljava/lang/Object;
 	public static fun plus (Lspace/kscience/kmath/operations/ExtendedField;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public static fun pow (Lspace/kscience/kmath/operations/ExtendedField;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public static fun rightSideNumberOperation (Lspace/kscience/kmath/operations/ExtendedField;Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
@@ -1660,13 +1563,12 @@ public final class space/kscience/kmath/operations/ExtendedField$DefaultImpls {
 	public static fun times (Lspace/kscience/kmath/operations/ExtendedField;Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
 	public static fun times (Lspace/kscience/kmath/operations/ExtendedField;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public static fun times (Lspace/kscience/kmath/operations/ExtendedField;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public static fun unaryMinus (Lspace/kscience/kmath/operations/ExtendedField;Ljava/lang/Object;)Ljava/lang/Object;
 	public static fun unaryOperation (Lspace/kscience/kmath/operations/ExtendedField;Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/Object;
 	public static fun unaryOperationFunction (Lspace/kscience/kmath/operations/ExtendedField;Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
 	public static fun unaryPlus (Lspace/kscience/kmath/operations/ExtendedField;Ljava/lang/Object;)Ljava/lang/Object;
 }
 
-public abstract interface class space/kscience/kmath/operations/ExtendedFieldOperations : space/kscience/kmath/operations/ExponentialOperations, space/kscience/kmath/operations/FieldOperations, space/kscience/kmath/operations/HyperbolicOperations, space/kscience/kmath/operations/PowerOperations, space/kscience/kmath/operations/TrigonometricOperations {
+public abstract interface class space/kscience/kmath/operations/ExtendedFieldOperations : space/kscience/kmath/operations/ExponentialOperations, space/kscience/kmath/operations/FieldOperations, space/kscience/kmath/operations/PowerOperations, space/kscience/kmath/operations/TrigonometricOperations {
 	public abstract fun tan (Ljava/lang/Object;)Ljava/lang/Object;
 	public abstract fun tanh (Ljava/lang/Object;)Ljava/lang/Object;
 	public abstract fun unaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
@@ -1676,7 +1578,6 @@ public final class space/kscience/kmath/operations/ExtendedFieldOperations$Defau
 	public static fun binaryOperation (Lspace/kscience/kmath/operations/ExtendedFieldOperations;Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public static fun binaryOperationFunction (Lspace/kscience/kmath/operations/ExtendedFieldOperations;Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public static fun bindSymbol (Lspace/kscience/kmath/operations/ExtendedFieldOperations;Ljava/lang/String;)Ljava/lang/Object;
-	public static fun div (Lspace/kscience/kmath/operations/ExtendedFieldOperations;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public static fun div (Lspace/kscience/kmath/operations/ExtendedFieldOperations;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public static fun minus (Lspace/kscience/kmath/operations/ExtendedFieldOperations;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public static fun plus (Lspace/kscience/kmath/operations/ExtendedFieldOperations;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
@@ -1684,32 +1585,32 @@ public final class space/kscience/kmath/operations/ExtendedFieldOperations$Defau
 	public static fun sqrt (Lspace/kscience/kmath/operations/ExtendedFieldOperations;Ljava/lang/Object;)Ljava/lang/Object;
 	public static fun tan (Lspace/kscience/kmath/operations/ExtendedFieldOperations;Ljava/lang/Object;)Ljava/lang/Object;
 	public static fun tanh (Lspace/kscience/kmath/operations/ExtendedFieldOperations;Ljava/lang/Object;)Ljava/lang/Object;
-	public static fun times (Lspace/kscience/kmath/operations/ExtendedFieldOperations;Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
-	public static fun times (Lspace/kscience/kmath/operations/ExtendedFieldOperations;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public static fun times (Lspace/kscience/kmath/operations/ExtendedFieldOperations;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public static fun unaryMinus (Lspace/kscience/kmath/operations/ExtendedFieldOperations;Ljava/lang/Object;)Ljava/lang/Object;
 	public static fun unaryOperation (Lspace/kscience/kmath/operations/ExtendedFieldOperations;Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/Object;
 	public static fun unaryOperationFunction (Lspace/kscience/kmath/operations/ExtendedFieldOperations;Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
 	public static fun unaryPlus (Lspace/kscience/kmath/operations/ExtendedFieldOperations;Ljava/lang/Object;)Ljava/lang/Object;
 }
 
-public abstract interface class space/kscience/kmath/operations/Field : space/kscience/kmath/operations/FieldOperations, space/kscience/kmath/operations/Ring {
-	public abstract fun div (Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
+public abstract interface class space/kscience/kmath/operations/Field : space/kscience/kmath/operations/FieldOperations, space/kscience/kmath/operations/NumericAlgebra, space/kscience/kmath/operations/Ring, space/kscience/kmath/operations/ScaleOperations {
+	public abstract fun number (Ljava/lang/Number;)Ljava/lang/Object;
 }
 
 public final class space/kscience/kmath/operations/Field$DefaultImpls {
 	public static fun binaryOperation (Lspace/kscience/kmath/operations/Field;Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public static fun binaryOperationFunction (Lspace/kscience/kmath/operations/Field;Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public static fun bindSymbol (Lspace/kscience/kmath/operations/Field;Ljava/lang/String;)Ljava/lang/Object;
-	public static fun div (Lspace/kscience/kmath/operations/Field;Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
 	public static fun div (Lspace/kscience/kmath/operations/Field;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public static fun div (Lspace/kscience/kmath/operations/Field;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+	public static fun leftSideNumberOperation (Lspace/kscience/kmath/operations/Field;Ljava/lang/String;Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
+	public static fun leftSideNumberOperationFunction (Lspace/kscience/kmath/operations/Field;Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public static fun minus (Lspace/kscience/kmath/operations/Field;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+	public static fun number (Lspace/kscience/kmath/operations/Field;Ljava/lang/Number;)Ljava/lang/Object;
 	public static fun plus (Lspace/kscience/kmath/operations/Field;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+	public static fun rightSideNumberOperation (Lspace/kscience/kmath/operations/Field;Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
+	public static fun rightSideNumberOperationFunction (Lspace/kscience/kmath/operations/Field;Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public static fun times (Lspace/kscience/kmath/operations/Field;Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
 	public static fun times (Lspace/kscience/kmath/operations/Field;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public static fun times (Lspace/kscience/kmath/operations/Field;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public static fun unaryMinus (Lspace/kscience/kmath/operations/Field;Ljava/lang/Object;)Ljava/lang/Object;
 	public static fun unaryOperation (Lspace/kscience/kmath/operations/Field;Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/Object;
 	public static fun unaryOperationFunction (Lspace/kscience/kmath/operations/Field;Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
 	public static fun unaryPlus (Lspace/kscience/kmath/operations/Field;Ljava/lang/Object;)Ljava/lang/Object;
@@ -1731,14 +1632,10 @@ public final class space/kscience/kmath/operations/FieldOperations$DefaultImpls
 	public static fun binaryOperation (Lspace/kscience/kmath/operations/FieldOperations;Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public static fun binaryOperationFunction (Lspace/kscience/kmath/operations/FieldOperations;Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public static fun bindSymbol (Lspace/kscience/kmath/operations/FieldOperations;Ljava/lang/String;)Ljava/lang/Object;
-	public static fun div (Lspace/kscience/kmath/operations/FieldOperations;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public static fun div (Lspace/kscience/kmath/operations/FieldOperations;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public static fun minus (Lspace/kscience/kmath/operations/FieldOperations;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public static fun plus (Lspace/kscience/kmath/operations/FieldOperations;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public static fun times (Lspace/kscience/kmath/operations/FieldOperations;Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
-	public static fun times (Lspace/kscience/kmath/operations/FieldOperations;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public static fun times (Lspace/kscience/kmath/operations/FieldOperations;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public static fun unaryMinus (Lspace/kscience/kmath/operations/FieldOperations;Ljava/lang/Object;)Ljava/lang/Object;
 	public static fun unaryOperation (Lspace/kscience/kmath/operations/FieldOperations;Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/Object;
 	public static fun unaryOperationFunction (Lspace/kscience/kmath/operations/FieldOperations;Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
 	public static fun unaryPlus (Lspace/kscience/kmath/operations/FieldOperations;Ljava/lang/Object;)Ljava/lang/Object;
@@ -1771,8 +1668,6 @@ public final class space/kscience/kmath/operations/FloatField : space/kscience/k
 	public synthetic fun cosh (Ljava/lang/Object;)Ljava/lang/Object;
 	public fun div (FF)Ljava/lang/Float;
 	public fun div (FLjava/lang/Number;)Ljava/lang/Float;
-	public fun div (Ljava/lang/Number;F)Ljava/lang/Float;
-	public synthetic fun div (Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
 	public synthetic fun div (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public synthetic fun div (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun divide (FF)Ljava/lang/Float;
@@ -1791,8 +1686,6 @@ public final class space/kscience/kmath/operations/FloatField : space/kscience/k
 	public fun minus (FF)Ljava/lang/Float;
 	public synthetic fun minus (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun multiply (FF)Ljava/lang/Float;
-	public fun multiply (FLjava/lang/Number;)Ljava/lang/Float;
-	public synthetic fun multiply (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public synthetic fun multiply (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun norm (F)Ljava/lang/Float;
 	public synthetic fun norm (Ljava/lang/Object;)Ljava/lang/Object;
@@ -1807,6 +1700,8 @@ public final class space/kscience/kmath/operations/FloatField : space/kscience/k
 	public fun rightSideNumberOperation (Ljava/lang/String;FLjava/lang/Number;)Ljava/lang/Float;
 	public synthetic fun rightSideNumberOperation (Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public fun rightSideNumberOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
+	public fun scale (FD)Ljava/lang/Float;
+	public synthetic fun scale (Ljava/lang/Object;D)Ljava/lang/Object;
 	public fun sin (F)Ljava/lang/Float;
 	public synthetic fun sin (Ljava/lang/Object;)Ljava/lang/Object;
 	public fun sinh (F)Ljava/lang/Float;
@@ -1832,39 +1727,6 @@ public final class space/kscience/kmath/operations/FloatField : space/kscience/k
 	public synthetic fun unaryPlus (Ljava/lang/Object;)Ljava/lang/Object;
 }
 
-public abstract interface class space/kscience/kmath/operations/HyperbolicOperations : space/kscience/kmath/operations/Algebra {
-	public static final field ACOSH_OPERATION Ljava/lang/String;
-	public static final field ASINH_OPERATION Ljava/lang/String;
-	public static final field ATANH_OPERATION Ljava/lang/String;
-	public static final field COSH_OPERATION Ljava/lang/String;
-	public static final field Companion Lspace/kscience/kmath/operations/HyperbolicOperations$Companion;
-	public static final field SINH_OPERATION Ljava/lang/String;
-	public static final field TANH_OPERATION Ljava/lang/String;
-	public abstract fun acosh (Ljava/lang/Object;)Ljava/lang/Object;
-	public abstract fun asinh (Ljava/lang/Object;)Ljava/lang/Object;
-	public abstract fun atanh (Ljava/lang/Object;)Ljava/lang/Object;
-	public abstract fun cosh (Ljava/lang/Object;)Ljava/lang/Object;
-	public abstract fun sinh (Ljava/lang/Object;)Ljava/lang/Object;
-	public abstract fun tanh (Ljava/lang/Object;)Ljava/lang/Object;
-}
-
-public final class space/kscience/kmath/operations/HyperbolicOperations$Companion {
-	public static final field ACOSH_OPERATION Ljava/lang/String;
-	public static final field ASINH_OPERATION Ljava/lang/String;
-	public static final field ATANH_OPERATION Ljava/lang/String;
-	public static final field COSH_OPERATION Ljava/lang/String;
-	public static final field SINH_OPERATION Ljava/lang/String;
-	public static final field TANH_OPERATION Ljava/lang/String;
-}
-
-public final class space/kscience/kmath/operations/HyperbolicOperations$DefaultImpls {
-	public static fun binaryOperation (Lspace/kscience/kmath/operations/HyperbolicOperations;Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public static fun binaryOperationFunction (Lspace/kscience/kmath/operations/HyperbolicOperations;Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
-	public static fun bindSymbol (Lspace/kscience/kmath/operations/HyperbolicOperations;Ljava/lang/String;)Ljava/lang/Object;
-	public static fun unaryOperation (Lspace/kscience/kmath/operations/HyperbolicOperations;Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/Object;
-	public static fun unaryOperationFunction (Lspace/kscience/kmath/operations/HyperbolicOperations;Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
-}
-
 public final class space/kscience/kmath/operations/IntRing : space/kscience/kmath/operations/Norm, space/kscience/kmath/operations/NumericAlgebra, space/kscience/kmath/operations/Ring {
 	public static final field INSTANCE Lspace/kscience/kmath/operations/IntRing;
 	public fun add (II)Ljava/lang/Integer;
@@ -1874,8 +1736,6 @@ public final class space/kscience/kmath/operations/IntRing : space/kscience/kmat
 	public fun binaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public fun bindSymbol (Ljava/lang/String;)Ljava/lang/Integer;
 	public synthetic fun bindSymbol (Ljava/lang/String;)Ljava/lang/Object;
-	public fun div (ILjava/lang/Number;)Ljava/lang/Integer;
-	public synthetic fun div (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public fun getOne ()Ljava/lang/Integer;
 	public synthetic fun getOne ()Ljava/lang/Object;
 	public fun getZero ()Ljava/lang/Integer;
@@ -1886,8 +1746,6 @@ public final class space/kscience/kmath/operations/IntRing : space/kscience/kmat
 	public fun minus (II)Ljava/lang/Integer;
 	public synthetic fun minus (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun multiply (II)Ljava/lang/Integer;
-	public fun multiply (ILjava/lang/Number;)Ljava/lang/Integer;
-	public synthetic fun multiply (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public synthetic fun multiply (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun norm (I)Ljava/lang/Integer;
 	public synthetic fun norm (Ljava/lang/Object;)Ljava/lang/Object;
@@ -1899,10 +1757,6 @@ public final class space/kscience/kmath/operations/IntRing : space/kscience/kmat
 	public synthetic fun rightSideNumberOperation (Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public fun rightSideNumberOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public fun times (II)Ljava/lang/Integer;
-	public fun times (ILjava/lang/Number;)Ljava/lang/Integer;
-	public fun times (Ljava/lang/Number;I)Ljava/lang/Integer;
-	public synthetic fun times (Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
-	public synthetic fun times (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public synthetic fun times (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun unaryMinus (I)Ljava/lang/Integer;
 	public synthetic fun unaryMinus (Ljava/lang/Object;)Ljava/lang/Object;
@@ -1923,7 +1777,7 @@ public final class space/kscience/kmath/operations/JBigDecimalField : space/ksci
 public final class space/kscience/kmath/operations/JBigDecimalField$Companion : space/kscience/kmath/operations/JBigDecimalFieldBase {
 }
 
-public abstract class space/kscience/kmath/operations/JBigDecimalFieldBase : space/kscience/kmath/operations/Field, space/kscience/kmath/operations/NumericAlgebra, space/kscience/kmath/operations/PowerOperations {
+public abstract class space/kscience/kmath/operations/JBigDecimalFieldBase : space/kscience/kmath/operations/Field, space/kscience/kmath/operations/NumericAlgebra, space/kscience/kmath/operations/PowerOperations, space/kscience/kmath/operations/ScaleOperations {
 	public fun <init> ()V
 	public synthetic fun add (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun add (Ljava/math/BigDecimal;Ljava/math/BigDecimal;)Ljava/math/BigDecimal;
@@ -1932,8 +1786,6 @@ public abstract class space/kscience/kmath/operations/JBigDecimalFieldBase : spa
 	public fun binaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public synthetic fun bindSymbol (Ljava/lang/String;)Ljava/lang/Object;
 	public fun bindSymbol (Ljava/lang/String;)Ljava/math/BigDecimal;
-	public synthetic fun div (Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun div (Ljava/lang/Number;Ljava/math/BigDecimal;)Ljava/math/BigDecimal;
 	public synthetic fun div (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public synthetic fun div (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun div (Ljava/math/BigDecimal;Ljava/lang/Number;)Ljava/math/BigDecimal;
@@ -1949,9 +1801,7 @@ public abstract class space/kscience/kmath/operations/JBigDecimalFieldBase : spa
 	public fun leftSideNumberOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public synthetic fun minus (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun minus (Ljava/math/BigDecimal;Ljava/math/BigDecimal;)Ljava/math/BigDecimal;
-	public synthetic fun multiply (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public synthetic fun multiply (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun multiply (Ljava/math/BigDecimal;Ljava/lang/Number;)Ljava/math/BigDecimal;
 	public fun multiply (Ljava/math/BigDecimal;Ljava/math/BigDecimal;)Ljava/math/BigDecimal;
 	public synthetic fun number (Ljava/lang/Number;)Ljava/lang/Object;
 	public fun number (Ljava/lang/Number;)Ljava/math/BigDecimal;
@@ -1964,6 +1814,8 @@ public abstract class space/kscience/kmath/operations/JBigDecimalFieldBase : spa
 	public synthetic fun rightSideNumberOperation (Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public fun rightSideNumberOperation (Ljava/lang/String;Ljava/math/BigDecimal;Ljava/lang/Number;)Ljava/math/BigDecimal;
 	public fun rightSideNumberOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
+	public synthetic fun scale (Ljava/lang/Object;D)Ljava/lang/Object;
+	public fun scale (Ljava/math/BigDecimal;D)Ljava/math/BigDecimal;
 	public synthetic fun sqrt (Ljava/lang/Object;)Ljava/lang/Object;
 	public fun sqrt (Ljava/math/BigDecimal;)Ljava/math/BigDecimal;
 	public synthetic fun times (Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
@@ -1981,7 +1833,7 @@ public abstract class space/kscience/kmath/operations/JBigDecimalFieldBase : spa
 	public fun unaryPlus (Ljava/math/BigDecimal;)Ljava/math/BigDecimal;
 }
 
-public final class space/kscience/kmath/operations/JBigIntegerField : space/kscience/kmath/operations/Field, space/kscience/kmath/operations/NumericAlgebra {
+public final class space/kscience/kmath/operations/JBigIntegerField : space/kscience/kmath/operations/NumericAlgebra, space/kscience/kmath/operations/Ring {
 	public static final field INSTANCE Lspace/kscience/kmath/operations/JBigIntegerField;
 	public synthetic fun add (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun add (Ljava/math/BigInteger;Ljava/math/BigInteger;)Ljava/math/BigInteger;
@@ -1990,14 +1842,6 @@ public final class space/kscience/kmath/operations/JBigIntegerField : space/ksci
 	public fun binaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public synthetic fun bindSymbol (Ljava/lang/String;)Ljava/lang/Object;
 	public fun bindSymbol (Ljava/lang/String;)Ljava/math/BigInteger;
-	public synthetic fun div (Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun div (Ljava/lang/Number;Ljava/math/BigInteger;)Ljava/math/BigInteger;
-	public synthetic fun div (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
-	public synthetic fun div (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun div (Ljava/math/BigInteger;Ljava/lang/Number;)Ljava/math/BigInteger;
-	public fun div (Ljava/math/BigInteger;Ljava/math/BigInteger;)Ljava/math/BigInteger;
-	public synthetic fun divide (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun divide (Ljava/math/BigInteger;Ljava/math/BigInteger;)Ljava/math/BigInteger;
 	public synthetic fun getOne ()Ljava/lang/Object;
 	public fun getOne ()Ljava/math/BigInteger;
 	public synthetic fun getZero ()Ljava/lang/Object;
@@ -2007,9 +1851,7 @@ public final class space/kscience/kmath/operations/JBigIntegerField : space/ksci
 	public fun leftSideNumberOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public synthetic fun minus (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun minus (Ljava/math/BigInteger;Ljava/math/BigInteger;)Ljava/math/BigInteger;
-	public synthetic fun multiply (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public synthetic fun multiply (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun multiply (Ljava/math/BigInteger;Ljava/lang/Number;)Ljava/math/BigInteger;
 	public fun multiply (Ljava/math/BigInteger;Ljava/math/BigInteger;)Ljava/math/BigInteger;
 	public synthetic fun number (Ljava/lang/Number;)Ljava/lang/Object;
 	public fun number (Ljava/lang/Number;)Ljava/math/BigInteger;
@@ -2018,11 +1860,7 @@ public final class space/kscience/kmath/operations/JBigIntegerField : space/ksci
 	public synthetic fun rightSideNumberOperation (Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public fun rightSideNumberOperation (Ljava/lang/String;Ljava/math/BigInteger;Ljava/lang/Number;)Ljava/math/BigInteger;
 	public fun rightSideNumberOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
-	public synthetic fun times (Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun times (Ljava/lang/Number;Ljava/math/BigInteger;)Ljava/math/BigInteger;
-	public synthetic fun times (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public synthetic fun times (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun times (Ljava/math/BigInteger;Ljava/lang/Number;)Ljava/math/BigInteger;
 	public fun times (Ljava/math/BigInteger;Ljava/math/BigInteger;)Ljava/math/BigInteger;
 	public synthetic fun unaryMinus (Ljava/lang/Object;)Ljava/lang/Object;
 	public fun unaryMinus (Ljava/math/BigInteger;)Ljava/math/BigInteger;
@@ -2045,8 +1883,6 @@ public final class space/kscience/kmath/operations/LongRing : space/kscience/kma
 	public fun binaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public fun bindSymbol (Ljava/lang/String;)Ljava/lang/Long;
 	public synthetic fun bindSymbol (Ljava/lang/String;)Ljava/lang/Object;
-	public fun div (JLjava/lang/Number;)Ljava/lang/Long;
-	public synthetic fun div (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public fun getOne ()Ljava/lang/Long;
 	public synthetic fun getOne ()Ljava/lang/Object;
 	public fun getZero ()Ljava/lang/Long;
@@ -2057,8 +1893,6 @@ public final class space/kscience/kmath/operations/LongRing : space/kscience/kma
 	public fun minus (JJ)Ljava/lang/Long;
 	public synthetic fun minus (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun multiply (JJ)Ljava/lang/Long;
-	public fun multiply (JLjava/lang/Number;)Ljava/lang/Long;
-	public synthetic fun multiply (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public synthetic fun multiply (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun norm (J)Ljava/lang/Long;
 	public synthetic fun norm (Ljava/lang/Object;)Ljava/lang/Object;
@@ -2070,10 +1904,6 @@ public final class space/kscience/kmath/operations/LongRing : space/kscience/kma
 	public synthetic fun rightSideNumberOperation (Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public fun rightSideNumberOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public fun times (JJ)Ljava/lang/Long;
-	public fun times (JLjava/lang/Number;)Ljava/lang/Long;
-	public fun times (Ljava/lang/Number;J)Ljava/lang/Long;
-	public synthetic fun times (Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
-	public synthetic fun times (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public synthetic fun times (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun unaryMinus (J)Ljava/lang/Long;
 	public synthetic fun unaryMinus (Ljava/lang/Object;)Ljava/lang/Object;
@@ -2088,6 +1918,25 @@ public abstract interface class space/kscience/kmath/operations/Norm {
 	public abstract fun norm (Ljava/lang/Object;)Ljava/lang/Object;
 }
 
+public final class space/kscience/kmath/operations/NumbersAddOperations$DefaultImpls {
+	public static fun binaryOperation (Lspace/kscience/kmath/operations/NumbersAddOperations;Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+	public static fun binaryOperationFunction (Lspace/kscience/kmath/operations/NumbersAddOperations;Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
+	public static fun bindSymbol (Lspace/kscience/kmath/operations/NumbersAddOperations;Ljava/lang/String;)Ljava/lang/Object;
+	public static fun leftSideNumberOperation (Lspace/kscience/kmath/operations/NumbersAddOperations;Ljava/lang/String;Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
+	public static fun leftSideNumberOperationFunction (Lspace/kscience/kmath/operations/NumbersAddOperations;Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
+	public static fun minus (Lspace/kscience/kmath/operations/NumbersAddOperations;Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
+	public static fun minus (Lspace/kscience/kmath/operations/NumbersAddOperations;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
+	public static fun minus (Lspace/kscience/kmath/operations/NumbersAddOperations;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+	public static fun plus (Lspace/kscience/kmath/operations/NumbersAddOperations;Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
+	public static fun plus (Lspace/kscience/kmath/operations/NumbersAddOperations;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
+	public static fun plus (Lspace/kscience/kmath/operations/NumbersAddOperations;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+	public static fun rightSideNumberOperation (Lspace/kscience/kmath/operations/NumbersAddOperations;Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
+	public static fun rightSideNumberOperationFunction (Lspace/kscience/kmath/operations/NumbersAddOperations;Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
+	public static fun unaryOperation (Lspace/kscience/kmath/operations/NumbersAddOperations;Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/Object;
+	public static fun unaryOperationFunction (Lspace/kscience/kmath/operations/NumbersAddOperations;Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
+	public static fun unaryPlus (Lspace/kscience/kmath/operations/NumbersAddOperations;Ljava/lang/Object;)Ljava/lang/Object;
+}
+
 public abstract interface class space/kscience/kmath/operations/NumericAlgebra : space/kscience/kmath/operations/Algebra {
 	public abstract fun leftSideNumberOperation (Ljava/lang/String;Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
 	public abstract fun leftSideNumberOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
@@ -2135,7 +1984,7 @@ public final class space/kscience/kmath/operations/PowerOperations$DefaultImpls
 	public static fun unaryOperationFunction (Lspace/kscience/kmath/operations/PowerOperations;Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
 }
 
-public final class space/kscience/kmath/operations/RealField : space/kscience/kmath/operations/ExtendedField, space/kscience/kmath/operations/Norm {
+public final class space/kscience/kmath/operations/RealField : space/kscience/kmath/operations/ExtendedField, space/kscience/kmath/operations/Norm, space/kscience/kmath/operations/ScaleOperations {
 	public static final field INSTANCE Lspace/kscience/kmath/operations/RealField;
 	public fun acos (D)Ljava/lang/Double;
 	public synthetic fun acos (Ljava/lang/Object;)Ljava/lang/Object;
@@ -2162,8 +2011,6 @@ public final class space/kscience/kmath/operations/RealField : space/kscience/km
 	public synthetic fun cosh (Ljava/lang/Object;)Ljava/lang/Object;
 	public fun div (DD)Ljava/lang/Double;
 	public fun div (DLjava/lang/Number;)Ljava/lang/Double;
-	public fun div (Ljava/lang/Number;D)Ljava/lang/Double;
-	public synthetic fun div (Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
 	public synthetic fun div (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public synthetic fun div (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun divide (DD)Ljava/lang/Double;
@@ -2182,8 +2029,6 @@ public final class space/kscience/kmath/operations/RealField : space/kscience/km
 	public fun minus (DD)Ljava/lang/Double;
 	public synthetic fun minus (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun multiply (DD)Ljava/lang/Double;
-	public fun multiply (DLjava/lang/Number;)Ljava/lang/Double;
-	public synthetic fun multiply (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public synthetic fun multiply (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun norm (D)Ljava/lang/Double;
 	public synthetic fun norm (Ljava/lang/Object;)Ljava/lang/Object;
@@ -2198,6 +2043,8 @@ public final class space/kscience/kmath/operations/RealField : space/kscience/km
 	public fun rightSideNumberOperation (Ljava/lang/String;DLjava/lang/Number;)Ljava/lang/Double;
 	public synthetic fun rightSideNumberOperation (Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public fun rightSideNumberOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
+	public fun scale (DD)Ljava/lang/Double;
+	public synthetic fun scale (Ljava/lang/Object;D)Ljava/lang/Object;
 	public fun sin (D)Ljava/lang/Double;
 	public synthetic fun sin (Ljava/lang/Object;)Ljava/lang/Object;
 	public fun sinh (D)Ljava/lang/Double;
@@ -2231,13 +2078,9 @@ public final class space/kscience/kmath/operations/Ring$DefaultImpls {
 	public static fun binaryOperation (Lspace/kscience/kmath/operations/Ring;Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public static fun binaryOperationFunction (Lspace/kscience/kmath/operations/Ring;Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public static fun bindSymbol (Lspace/kscience/kmath/operations/Ring;Ljava/lang/String;)Ljava/lang/Object;
-	public static fun div (Lspace/kscience/kmath/operations/Ring;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public static fun minus (Lspace/kscience/kmath/operations/Ring;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public static fun plus (Lspace/kscience/kmath/operations/Ring;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public static fun times (Lspace/kscience/kmath/operations/Ring;Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
-	public static fun times (Lspace/kscience/kmath/operations/Ring;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public static fun times (Lspace/kscience/kmath/operations/Ring;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public static fun unaryMinus (Lspace/kscience/kmath/operations/Ring;Ljava/lang/Object;)Ljava/lang/Object;
 	public static fun unaryOperation (Lspace/kscience/kmath/operations/Ring;Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/Object;
 	public static fun unaryOperationFunction (Lspace/kscience/kmath/operations/Ring;Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
 	public static fun unaryPlus (Lspace/kscience/kmath/operations/Ring;Ljava/lang/Object;)Ljava/lang/Object;
@@ -2259,41 +2102,30 @@ public final class space/kscience/kmath/operations/RingOperations$DefaultImpls {
 	public static fun binaryOperation (Lspace/kscience/kmath/operations/RingOperations;Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public static fun binaryOperationFunction (Lspace/kscience/kmath/operations/RingOperations;Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public static fun bindSymbol (Lspace/kscience/kmath/operations/RingOperations;Ljava/lang/String;)Ljava/lang/Object;
-	public static fun div (Lspace/kscience/kmath/operations/RingOperations;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public static fun minus (Lspace/kscience/kmath/operations/RingOperations;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public static fun plus (Lspace/kscience/kmath/operations/RingOperations;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public static fun times (Lspace/kscience/kmath/operations/RingOperations;Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
-	public static fun times (Lspace/kscience/kmath/operations/RingOperations;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public static fun times (Lspace/kscience/kmath/operations/RingOperations;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public static fun unaryMinus (Lspace/kscience/kmath/operations/RingOperations;Ljava/lang/Object;)Ljava/lang/Object;
 	public static fun unaryOperation (Lspace/kscience/kmath/operations/RingOperations;Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/Object;
 	public static fun unaryOperationFunction (Lspace/kscience/kmath/operations/RingOperations;Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
 	public static fun unaryPlus (Lspace/kscience/kmath/operations/RingOperations;Ljava/lang/Object;)Ljava/lang/Object;
 }
 
-public final class space/kscience/kmath/operations/RingWithNumbers$DefaultImpls {
-	public static fun binaryOperation (Lspace/kscience/kmath/operations/RingWithNumbers;Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public static fun binaryOperationFunction (Lspace/kscience/kmath/operations/RingWithNumbers;Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
-	public static fun bindSymbol (Lspace/kscience/kmath/operations/RingWithNumbers;Ljava/lang/String;)Ljava/lang/Object;
-	public static fun div (Lspace/kscience/kmath/operations/RingWithNumbers;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
-	public static fun leftSideNumberOperation (Lspace/kscience/kmath/operations/RingWithNumbers;Ljava/lang/String;Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
-	public static fun leftSideNumberOperationFunction (Lspace/kscience/kmath/operations/RingWithNumbers;Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
-	public static fun minus (Lspace/kscience/kmath/operations/RingWithNumbers;Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
-	public static fun minus (Lspace/kscience/kmath/operations/RingWithNumbers;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
-	public static fun minus (Lspace/kscience/kmath/operations/RingWithNumbers;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public static fun number (Lspace/kscience/kmath/operations/RingWithNumbers;Ljava/lang/Number;)Ljava/lang/Object;
-	public static fun plus (Lspace/kscience/kmath/operations/RingWithNumbers;Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
-	public static fun plus (Lspace/kscience/kmath/operations/RingWithNumbers;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
-	public static fun plus (Lspace/kscience/kmath/operations/RingWithNumbers;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public static fun rightSideNumberOperation (Lspace/kscience/kmath/operations/RingWithNumbers;Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
-	public static fun rightSideNumberOperationFunction (Lspace/kscience/kmath/operations/RingWithNumbers;Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
-	public static fun times (Lspace/kscience/kmath/operations/RingWithNumbers;Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
-	public static fun times (Lspace/kscience/kmath/operations/RingWithNumbers;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
-	public static fun times (Lspace/kscience/kmath/operations/RingWithNumbers;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public static fun unaryMinus (Lspace/kscience/kmath/operations/RingWithNumbers;Ljava/lang/Object;)Ljava/lang/Object;
-	public static fun unaryOperation (Lspace/kscience/kmath/operations/RingWithNumbers;Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/Object;
-	public static fun unaryOperationFunction (Lspace/kscience/kmath/operations/RingWithNumbers;Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
-	public static fun unaryPlus (Lspace/kscience/kmath/operations/RingWithNumbers;Ljava/lang/Object;)Ljava/lang/Object;
+public abstract interface class space/kscience/kmath/operations/ScaleOperations : space/kscience/kmath/operations/Algebra {
+	public abstract fun div (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
+	public abstract fun scale (Ljava/lang/Object;D)Ljava/lang/Object;
+	public abstract fun times (Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
+	public abstract fun times (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
+}
+
+public final class space/kscience/kmath/operations/ScaleOperations$DefaultImpls {
+	public static fun binaryOperation (Lspace/kscience/kmath/operations/ScaleOperations;Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+	public static fun binaryOperationFunction (Lspace/kscience/kmath/operations/ScaleOperations;Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
+	public static fun bindSymbol (Lspace/kscience/kmath/operations/ScaleOperations;Ljava/lang/String;)Ljava/lang/Object;
+	public static fun div (Lspace/kscience/kmath/operations/ScaleOperations;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
+	public static fun times (Lspace/kscience/kmath/operations/ScaleOperations;Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
+	public static fun times (Lspace/kscience/kmath/operations/ScaleOperations;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
+	public static fun unaryOperation (Lspace/kscience/kmath/operations/ScaleOperations;Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/Object;
+	public static fun unaryOperationFunction (Lspace/kscience/kmath/operations/ScaleOperations;Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
 }
 
 public final class space/kscience/kmath/operations/ShortRing : space/kscience/kmath/operations/Norm, space/kscience/kmath/operations/NumericAlgebra, space/kscience/kmath/operations/Ring {
@@ -2305,8 +2137,6 @@ public final class space/kscience/kmath/operations/ShortRing : space/kscience/km
 	public fun binaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public synthetic fun bindSymbol (Ljava/lang/String;)Ljava/lang/Object;
 	public fun bindSymbol (Ljava/lang/String;)Ljava/lang/Short;
-	public synthetic fun div (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
-	public fun div (SLjava/lang/Number;)Ljava/lang/Short;
 	public synthetic fun getOne ()Ljava/lang/Object;
 	public fun getOne ()Ljava/lang/Short;
 	public synthetic fun getZero ()Ljava/lang/Object;
@@ -2316,9 +2146,7 @@ public final class space/kscience/kmath/operations/ShortRing : space/kscience/km
 	public fun leftSideNumberOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public synthetic fun minus (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun minus (SS)Ljava/lang/Short;
-	public synthetic fun multiply (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public synthetic fun multiply (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun multiply (SLjava/lang/Number;)Ljava/lang/Short;
 	public fun multiply (SS)Ljava/lang/Short;
 	public synthetic fun norm (Ljava/lang/Object;)Ljava/lang/Object;
 	public fun norm (S)Ljava/lang/Short;
@@ -2329,11 +2157,7 @@ public final class space/kscience/kmath/operations/ShortRing : space/kscience/km
 	public synthetic fun rightSideNumberOperation (Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public fun rightSideNumberOperation (Ljava/lang/String;SLjava/lang/Number;)Ljava/lang/Short;
 	public fun rightSideNumberOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
-	public synthetic fun times (Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun times (Ljava/lang/Number;S)Ljava/lang/Short;
-	public synthetic fun times (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public synthetic fun times (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun times (SLjava/lang/Number;)Ljava/lang/Short;
 	public fun times (SS)Ljava/lang/Short;
 	public synthetic fun unaryMinus (Ljava/lang/Object;)Ljava/lang/Object;
 	public fun unaryMinus (S)Ljava/lang/Short;
@@ -2352,12 +2176,8 @@ public final class space/kscience/kmath/operations/Space$DefaultImpls {
 	public static fun binaryOperation (Lspace/kscience/kmath/operations/Space;Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public static fun binaryOperationFunction (Lspace/kscience/kmath/operations/Space;Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public static fun bindSymbol (Lspace/kscience/kmath/operations/Space;Ljava/lang/String;)Ljava/lang/Object;
-	public static fun div (Lspace/kscience/kmath/operations/Space;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public static fun minus (Lspace/kscience/kmath/operations/Space;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public static fun plus (Lspace/kscience/kmath/operations/Space;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public static fun times (Lspace/kscience/kmath/operations/Space;Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
-	public static fun times (Lspace/kscience/kmath/operations/Space;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
-	public static fun unaryMinus (Lspace/kscience/kmath/operations/Space;Ljava/lang/Object;)Ljava/lang/Object;
 	public static fun unaryOperation (Lspace/kscience/kmath/operations/Space;Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/Object;
 	public static fun unaryOperationFunction (Lspace/kscience/kmath/operations/Space;Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
 	public static fun unaryPlus (Lspace/kscience/kmath/operations/Space;Ljava/lang/Object;)Ljava/lang/Object;
@@ -2369,12 +2189,8 @@ public abstract interface class space/kscience/kmath/operations/SpaceOperations
 	public static final field PLUS_OPERATION Ljava/lang/String;
 	public abstract fun add (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public abstract fun binaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
-	public abstract fun div (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public abstract fun minus (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public abstract fun multiply (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public abstract fun plus (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public abstract fun times (Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
-	public abstract fun times (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public abstract fun unaryMinus (Ljava/lang/Object;)Ljava/lang/Object;
 	public abstract fun unaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
 	public abstract fun unaryPlus (Ljava/lang/Object;)Ljava/lang/Object;
@@ -2389,12 +2205,8 @@ public final class space/kscience/kmath/operations/SpaceOperations$DefaultImpls
 	public static fun binaryOperation (Lspace/kscience/kmath/operations/SpaceOperations;Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public static fun binaryOperationFunction (Lspace/kscience/kmath/operations/SpaceOperations;Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public static fun bindSymbol (Lspace/kscience/kmath/operations/SpaceOperations;Ljava/lang/String;)Ljava/lang/Object;
-	public static fun div (Lspace/kscience/kmath/operations/SpaceOperations;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public static fun minus (Lspace/kscience/kmath/operations/SpaceOperations;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public static fun plus (Lspace/kscience/kmath/operations/SpaceOperations;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public static fun times (Lspace/kscience/kmath/operations/SpaceOperations;Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
-	public static fun times (Lspace/kscience/kmath/operations/SpaceOperations;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
-	public static fun unaryMinus (Lspace/kscience/kmath/operations/SpaceOperations;Ljava/lang/Object;)Ljava/lang/Object;
 	public static fun unaryOperation (Lspace/kscience/kmath/operations/SpaceOperations;Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/Object;
 	public static fun unaryOperationFunction (Lspace/kscience/kmath/operations/SpaceOperations;Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
 	public static fun unaryPlus (Lspace/kscience/kmath/operations/SpaceOperations;Ljava/lang/Object;)Ljava/lang/Object;
@@ -2776,8 +2588,6 @@ public final class space/kscience/kmath/structures/RealBufferField : space/kscie
 	public fun cos-LGjt3BI (Lspace/kscience/kmath/structures/Buffer;)[D
 	public synthetic fun cosh (Ljava/lang/Object;)Ljava/lang/Object;
 	public fun cosh-LGjt3BI (Lspace/kscience/kmath/structures/Buffer;)[D
-	public synthetic fun div (Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun div (Ljava/lang/Number;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
 	public synthetic fun div (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public synthetic fun div (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun div (Lspace/kscience/kmath/structures/Buffer;Ljava/lang/Number;)Lspace/kscience/kmath/structures/Buffer;
@@ -2798,9 +2608,7 @@ public final class space/kscience/kmath/structures/RealBufferField : space/kscie
 	public fun ln-LGjt3BI (Lspace/kscience/kmath/structures/Buffer;)[D
 	public synthetic fun minus (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun minus (Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-	public synthetic fun multiply (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public synthetic fun multiply (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun multiply-8hrHhI4 (Lspace/kscience/kmath/structures/Buffer;Ljava/lang/Number;)[D
 	public fun multiply-8hrHhI4 (Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)[D
 	public synthetic fun number (Ljava/lang/Number;)Ljava/lang/Object;
 	public fun number (Ljava/lang/Number;)Lspace/kscience/kmath/structures/Buffer;
@@ -2813,6 +2621,8 @@ public final class space/kscience/kmath/structures/RealBufferField : space/kscie
 	public synthetic fun rightSideNumberOperation (Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public fun rightSideNumberOperation (Ljava/lang/String;Lspace/kscience/kmath/structures/Buffer;Ljava/lang/Number;)Lspace/kscience/kmath/structures/Buffer;
 	public fun rightSideNumberOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
+	public synthetic fun scale (Ljava/lang/Object;D)Ljava/lang/Object;
+	public fun scale-8hrHhI4 (Lspace/kscience/kmath/structures/Buffer;D)[D
 	public synthetic fun sin (Ljava/lang/Object;)Ljava/lang/Object;
 	public fun sin-LGjt3BI (Lspace/kscience/kmath/structures/Buffer;)[D
 	public synthetic fun sinh (Ljava/lang/Object;)Ljava/lang/Object;
@@ -2863,9 +2673,7 @@ public final class space/kscience/kmath/structures/RealBufferFieldOperations : s
 	public fun cos-LGjt3BI (Lspace/kscience/kmath/structures/Buffer;)[D
 	public synthetic fun cosh (Ljava/lang/Object;)Ljava/lang/Object;
 	public fun cosh-LGjt3BI (Lspace/kscience/kmath/structures/Buffer;)[D
-	public synthetic fun div (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public synthetic fun div (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun div (Lspace/kscience/kmath/structures/Buffer;Ljava/lang/Number;)Lspace/kscience/kmath/structures/Buffer;
 	public fun div (Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
 	public synthetic fun divide (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun divide-8hrHhI4 (Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)[D
@@ -2875,9 +2683,7 @@ public final class space/kscience/kmath/structures/RealBufferFieldOperations : s
 	public fun ln-LGjt3BI (Lspace/kscience/kmath/structures/Buffer;)[D
 	public synthetic fun minus (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun minus (Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-	public synthetic fun multiply (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public synthetic fun multiply (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun multiply-8hrHhI4 (Lspace/kscience/kmath/structures/Buffer;Ljava/lang/Number;)[D
 	public fun multiply-8hrHhI4 (Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)[D
 	public synthetic fun plus (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun plus (Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
@@ -2895,14 +2701,10 @@ public final class space/kscience/kmath/structures/RealBufferFieldOperations : s
 	public fun tan-LGjt3BI (Lspace/kscience/kmath/structures/Buffer;)[D
 	public synthetic fun tanh (Ljava/lang/Object;)Ljava/lang/Object;
 	public fun tanh-LGjt3BI (Lspace/kscience/kmath/structures/Buffer;)[D
-	public synthetic fun times (Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun times (Ljava/lang/Number;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-	public synthetic fun times (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public synthetic fun times (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun times (Lspace/kscience/kmath/structures/Buffer;Ljava/lang/Number;)Lspace/kscience/kmath/structures/Buffer;
 	public fun times (Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
 	public synthetic fun unaryMinus (Ljava/lang/Object;)Ljava/lang/Object;
-	public fun unaryMinus (Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
+	public fun unaryMinus-LGjt3BI (Lspace/kscience/kmath/structures/Buffer;)[D
 	public synthetic fun unaryOperation (Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun unaryOperation (Ljava/lang/String;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
 	public fun unaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/HyperSquareDomain.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/HyperSquareDomain.kt
index 3d0c6d3b8..c948f8672 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/HyperSquareDomain.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/HyperSquareDomain.kt
@@ -16,8 +16,8 @@
 package space.kscience.kmath.domains
 
 import space.kscience.kmath.linear.Point
+import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.structures.Buffer
-import space.kscience.kmath.structures.RealBuffer
 import space.kscience.kmath.structures.indices
 
 /**
@@ -26,6 +26,7 @@ import space.kscience.kmath.structures.indices
  *
  * @author Alexander Nozik
  */
+@UnstableKMathAPI
 public class HyperSquareDomain(private val lower: Buffer<Double>, private val upper: Buffer<Double>) : RealDomain {
     public override val dimension: Int get() = lower.size
 
@@ -33,26 +34,10 @@ public class HyperSquareDomain(private val lower: Buffer<Double>, private val up
         point[i] in lower[i]..upper[i]
     }
 
-    public override fun getLowerBound(num: Int, point: Point<Double>): Double = lower[num]
-
     public override fun getLowerBound(num: Int): Double = lower[num]
 
-    public override fun getUpperBound(num: Int, point: Point<Double>): Double = upper[num]
-
     public override fun getUpperBound(num: Int): Double = upper[num]
 
-    public override fun nearestInDomain(point: Point<Double>): Point<Double> {
-        val res = DoubleArray(point.size) { i ->
-            when {
-                point[i] < lower[i] -> lower[i]
-                point[i] > upper[i] -> upper[i]
-                else -> point[i]
-            }
-        }
-
-        return RealBuffer(*res)
-    }
-
     public override fun volume(): Double {
         var res = 1.0
 
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/RealDomain.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/RealDomain.kt
index 13555dad9..c20cbfec1 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/RealDomain.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/RealDomain.kt
@@ -15,45 +15,27 @@
  */
 package space.kscience.kmath.domains
 
-import space.kscience.kmath.linear.Point
+import space.kscience.kmath.misc.UnstableKMathAPI
 
 /**
  * n-dimensional volume
  *
  * @author Alexander Nozik
  */
+@UnstableKMathAPI
 public interface RealDomain : Domain<Double> {
-    public fun nearestInDomain(point: Point<Double>): Point<Double>
-
-    /**
-     * The lower edge for the domain going down from point
-     * @param num
-     * @param point
-     * @return
-     */
-    public fun getLowerBound(num: Int, point: Point<Double>): Double?
-
-    /**
-     * The upper edge of the domain going up from point
-     * @param num
-     * @param point
-     * @return
-     */
-    public fun getUpperBound(num: Int, point: Point<Double>): Double?
 
     /**
      * Global lower edge
-     * @param num
-     * @return
+     * @param num axis number
      */
-    public fun getLowerBound(num: Int): Double?
+    public fun getLowerBound(num: Int): Double
 
     /**
      * Global upper edge
-     * @param num
-     * @return
+     * @param num axis number
      */
-    public fun getUpperBound(num: Int): Double?
+    public fun getUpperBound(num: Int): Double
 
     /**
      * Hyper volume
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/UnconstrainedDomain.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/UnconstrainedDomain.kt
index f1bcc50ad..002caac50 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/UnconstrainedDomain.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/UnconstrainedDomain.kt
@@ -16,19 +16,15 @@
 package space.kscience.kmath.domains
 
 import space.kscience.kmath.linear.Point
+import space.kscience.kmath.misc.UnstableKMathAPI
 
+@UnstableKMathAPI
 public class UnconstrainedDomain(public override val dimension: Int) : RealDomain {
     public override operator fun contains(point: Point<Double>): Boolean = true
 
-    public override fun getLowerBound(num: Int, point: Point<Double>): Double? = Double.NEGATIVE_INFINITY
+    public override fun getLowerBound(num: Int): Double = Double.NEGATIVE_INFINITY
 
-    public override fun getLowerBound(num: Int): Double? = Double.NEGATIVE_INFINITY
-
-    public override fun getUpperBound(num: Int, point: Point<Double>): Double? = Double.POSITIVE_INFINITY
-
-    public override fun getUpperBound(num: Int): Double? = Double.POSITIVE_INFINITY
-
-    public override fun nearestInDomain(point: Point<Double>): Point<Double> = point
+    public override fun getUpperBound(num: Int): Double = Double.POSITIVE_INFINITY
 
     public override fun volume(): Double = Double.POSITIVE_INFINITY
 }
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/UnivariateDomain.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/UnivariateDomain.kt
index 36cd4afa7..d20349960 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/UnivariateDomain.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/UnivariateDomain.kt
@@ -1,11 +1,11 @@
 package space.kscience.kmath.domains
 
 import space.kscience.kmath.linear.Point
-import space.kscience.kmath.structures.asBuffer
+import space.kscience.kmath.misc.UnstableKMathAPI
 
+@UnstableKMathAPI
 public inline class UnivariateDomain(public val range: ClosedFloatingPointRange<Double>) : RealDomain {
-    public override val dimension: Int
-        get() = 1
+    public override val dimension: Int get() = 1
 
     public operator fun contains(d: Double): Boolean = range.contains(d)
 
@@ -14,33 +14,12 @@ public inline class UnivariateDomain(public val range: ClosedFloatingPointRange<
         return contains(point[0])
     }
 
-    public override fun nearestInDomain(point: Point<Double>): Point<Double> {
-        require(point.size == 1)
-        val value = point[0]
-
-        return when {
-            value in range -> point
-            value >= range.endInclusive -> doubleArrayOf(range.endInclusive).asBuffer()
-            else -> doubleArrayOf(range.start).asBuffer()
-        }
-    }
-
-    public override fun getLowerBound(num: Int, point: Point<Double>): Double? {
+    public override fun getLowerBound(num: Int): Double {
         require(num == 0)
         return range.start
     }
 
-    public override fun getUpperBound(num: Int, point: Point<Double>): Double? {
-        require(num == 0)
-        return range.endInclusive
-    }
-
-    public override fun getLowerBound(num: Int): Double? {
-        require(num == 0)
-        return range.start
-    }
-
-    public override fun getUpperBound(num: Int): Double? {
+    public override fun getUpperBound(num: Int): Double {
         require(num == 0)
         return range.endInclusive
     }
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/FunctionalExpressionAlgebra.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/FunctionalExpressionAlgebra.kt
index 5177bc868..3c23d0ecf 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/FunctionalExpressionAlgebra.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/FunctionalExpressionAlgebra.kt
@@ -48,18 +48,21 @@ public open class FunctionalExpressionSpace<T, A : Space<T>>(
 ) : FunctionalExpressionAlgebra<T, A>(algebra), Space<Expression<T>> {
     public override val zero: Expression<T> get() = const(algebra.zero)
 
+    override fun Expression<T>.unaryMinus(): Expression<T> =
+        unaryOperation(SpaceOperations.MINUS_OPERATION, this)
+
     /**
      * Builds an Expression of addition of two another expressions.
      */
     public override fun add(a: Expression<T>, b: Expression<T>): Expression<T> =
-        binaryOperationFunction(SpaceOperations.PLUS_OPERATION)(a, b)
+        binaryOperation(SpaceOperations.PLUS_OPERATION, a, b)
 
-    /**
-     * Builds an Expression of multiplication of expression by number.
-     */
-    public override fun multiply(a: Expression<T>, k: Number): Expression<T> = Expression { arguments ->
-        algebra.multiply(a.invoke(arguments), k)
-    }
+//    /**
+//     * Builds an Expression of multiplication of expression by number.
+//     */
+//    public override fun multiply(a: Expression<T>, k: Number): Expression<T> = Expression { arguments ->
+//        algebra.multiply(a.invoke(arguments), k)
+//    }
 
     public operator fun Expression<T>.plus(arg: T): Expression<T> = this + const(arg)
     public operator fun Expression<T>.minus(arg: T): Expression<T> = this - const(arg)
@@ -71,13 +74,13 @@ public open class FunctionalExpressionSpace<T, A : Space<T>>(
 
     public override fun binaryOperationFunction(operation: String): (left: Expression<T>, right: Expression<T>) -> Expression<T> =
         super<FunctionalExpressionAlgebra>.binaryOperationFunction(operation)
+
 }
 
 public open class FunctionalExpressionRing<T, A : Ring<T>>(
     algebra: A,
 ) : FunctionalExpressionSpace<T, A>(algebra), Ring<Expression<T>> {
-    public override val one: Expression<T>
-        get() = const(algebra.one)
+    public override val one: Expression<T> get() = const(algebra.one)
 
     /**
      * Builds an Expression of multiplication of two expressions.
@@ -95,9 +98,10 @@ public open class FunctionalExpressionRing<T, A : Ring<T>>(
         super<FunctionalExpressionSpace>.binaryOperationFunction(operation)
 }
 
-public open class FunctionalExpressionField<T, A : Field<T>>(
+public open class FunctionalExpressionField<T, A:  Field<T>>(
     algebra: A,
-) : FunctionalExpressionRing<T, A>(algebra), Field<Expression<T>> {
+) : FunctionalExpressionRing<T, A>(algebra), Field<Expression<T>>,
+    ScaleOperations<Expression<T>> {
     /**
      * Builds an Expression of division an expression by another one.
      */
@@ -112,6 +116,10 @@ public open class FunctionalExpressionField<T, A : Field<T>>(
 
     public override fun binaryOperationFunction(operation: String): (left: Expression<T>, right: Expression<T>) -> Expression<T> =
         super<FunctionalExpressionRing>.binaryOperationFunction(operation)
+
+    override fun scale(a: Expression<T>, value: Double): Expression<T> = algebra {
+        Expression { args -> a(args) * value }
+    }
 }
 
 public open class FunctionalExpressionExtendedField<T, A : ExtendedField<T>>(
@@ -160,5 +168,6 @@ public inline fun <T, A : Ring<T>> A.expressionInRing(block: FunctionalExpressio
 public inline fun <T, A : Field<T>> A.expressionInField(block: FunctionalExpressionField<T, A>.() -> Expression<T>): Expression<T> =
     FunctionalExpressionField(this).block()
 
-public inline fun <T, A : ExtendedField<T>> A.expressionInExtendedField(block: FunctionalExpressionExtendedField<T, A>.() -> Expression<T>): Expression<T> =
-    FunctionalExpressionExtendedField(this).block()
+public inline fun <T, A : ExtendedField<T>> A.expressionInExtendedField(
+    block: FunctionalExpressionExtendedField<T, A>.() -> Expression<T>,
+): Expression<T> = FunctionalExpressionExtendedField(this).block()
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/SimpleAutoDiff.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/SimpleAutoDiff.kt
index c710ba679..4b5b3311e 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/SimpleAutoDiff.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/SimpleAutoDiff.kt
@@ -47,36 +47,6 @@ public fun <T : Any> DerivationResult<T>.grad(vararg variables: Symbol): Point<T
     return variables.map(::derivative).asBuffer()
 }
 
-/**
- * Runs differentiation and establishes [SimpleAutoDiffField] context inside the block of code.
- *
- * The partial derivatives are placed in argument `d` variable
- *
- * Example:
- * ```
- * val x by symbol // define variable(s) and their values
- * val y = RealField.withAutoDiff() { sqr(x) + 5 * x + 3 } // write formulate in deriv context
- * assertEquals(17.0, y.x) // the value of result (y)
- * assertEquals(9.0, x.d)  // dy/dx
- * ```
- *
- * @param body the action in [SimpleAutoDiffField] context returning [AutoDiffVariable] to differentiate with respect to.
- * @return the result of differentiation.
- */
-public fun <T : Any, F : Field<T>> F.simpleAutoDiff(
-    bindings: Map<Symbol, T>,
-    body: SimpleAutoDiffField<T, F>.() -> AutoDiffValue<T>,
-): DerivationResult<T> {
-    contract { callsInPlace(body, InvocationKind.EXACTLY_ONCE) }
-
-    return SimpleAutoDiffField(this, bindings).differentiate(body)
-}
-
-public fun <T : Any, F : Field<T>> F.simpleAutoDiff(
-    vararg bindings: Pair<Symbol, T>,
-    body: SimpleAutoDiffField<T, F>.() -> AutoDiffValue<T>,
-): DerivationResult<T> = simpleAutoDiff(bindings.toMap(), body)
-
 /**
  * Represents field in context of which functions can be derived.
  */
@@ -84,12 +54,9 @@ public fun <T : Any, F : Field<T>> F.simpleAutoDiff(
 public open class SimpleAutoDiffField<T : Any, F : Field<T>>(
     public val context: F,
     bindings: Map<Symbol, T>,
-) : Field<AutoDiffValue<T>>, ExpressionAlgebra<T, AutoDiffValue<T>>, RingWithNumbers<AutoDiffValue<T>> {
-    public override val zero: AutoDiffValue<T>
-        get() = const(context.zero)
-
-    public override val one: AutoDiffValue<T>
-        get() = const(context.one)
+) : Field<AutoDiffValue<T>>, ExpressionAlgebra<T, AutoDiffValue<T>>, NumbersAddOperations<AutoDiffValue<T>> {
+    public override val zero: AutoDiffValue<T> get() = const(context.zero)
+    public override val one: AutoDiffValue<T> get() = const(context.one)
 
     // this stack contains pairs of blocks and values to apply them to
     private var stack: Array<Any?> = arrayOfNulls<Any?>(8)
@@ -137,6 +104,8 @@ public open class SimpleAutoDiffField<T : Any, F : Field<T>>(
 
     override fun const(value: T): AutoDiffValue<T> = AutoDiffValue(value)
 
+    override fun number(value: Number): AutoDiffValue<T> = const { one * value }
+
     /**
      * A variable accessing inner state of derivatives.
      * Use this value in inner builders to avoid creating additional derivative bindings.
@@ -175,21 +144,24 @@ public open class SimpleAutoDiffField<T : Any, F : Field<T>>(
         return DerivationResult(result.value, bindings.mapValues { it.value.d }, context)
     }
 
-    // Overloads for Double constants
+//    // Overloads for Double constants
+//
+//    public override operator fun Number.plus(b: AutoDiffValue<T>): AutoDiffValue<T> =
+//        derive(const { this@plus.toDouble() * one + b.value }) { z ->
+//            b.d += z.d
+//        }
+//
+//    public override operator fun AutoDiffValue<T>.plus(b: Number): AutoDiffValue<T> = b.plus(this)
+//
+//    public override operator fun Number.minus(b: AutoDiffValue<T>): AutoDiffValue<T> =
+//        derive(const { this@minus.toDouble() * one - b.value }) { z -> b.d -= z.d }
+//
+//    public override operator fun AutoDiffValue<T>.minus(b: Number): AutoDiffValue<T> =
+//        derive(const { this@minus.value - one * b.toDouble() }) { z -> d += z.d }
 
-    public override operator fun Number.plus(b: AutoDiffValue<T>): AutoDiffValue<T> =
-        derive(const { this@plus.toDouble() * one + b.value }) { z ->
-            b.d += z.d
-        }
-
-    public override operator fun AutoDiffValue<T>.plus(b: Number): AutoDiffValue<T> = b.plus(this)
-
-    public override operator fun Number.minus(b: AutoDiffValue<T>): AutoDiffValue<T> =
-        derive(const { this@minus.toDouble() * one - b.value }) { z -> b.d -= z.d }
-
-    public override operator fun AutoDiffValue<T>.minus(b: Number): AutoDiffValue<T> =
-        derive(const { this@minus.value - one * b.toDouble() }) { z -> this@minus.d += z.d }
 
+    override fun AutoDiffValue<T>.unaryMinus(): AutoDiffValue<T> =
+        derive(const { -value }) { z -> d -= z.d }
 
     // Basic math (+, -, *, /)
 
@@ -211,12 +183,44 @@ public open class SimpleAutoDiffField<T : Any, F : Field<T>>(
             b.d -= z.d * a.value / (b.value * b.value)
         }
 
-    public override fun multiply(a: AutoDiffValue<T>, k: Number): AutoDiffValue<T> =
-        derive(const { k.toDouble() * a.value }) { z ->
-            a.d += z.d * k.toDouble()
+    public override fun scale(a: AutoDiffValue<T>, value: Double): AutoDiffValue<T> =
+        derive(const { value * a.value }) { z ->
+            a.d += z.d * value
         }
 }
 
+
+/**
+ * Runs differentiation and establishes [SimpleAutoDiffField] context inside the block of code.
+ *
+ * The partial derivatives are placed in argument `d` variable
+ *
+ * Example:
+ * ```
+ * val x by symbol // define variable(s) and their values
+ * val y = RealField.withAutoDiff() { sqr(x) + 5 * x + 3 } // write formulate in deriv context
+ * assertEquals(17.0, y.x) // the value of result (y)
+ * assertEquals(9.0, x.d)  // dy/dx
+ * ```
+ *
+ * @param body the action in [SimpleAutoDiffField] context returning [AutoDiffVariable] to differentiate with respect to.
+ * @return the result of differentiation.
+ */
+public fun <T : Any, F : Field<T>> F.simpleAutoDiff(
+    bindings: Map<Symbol, T>,
+    body: SimpleAutoDiffField<T, F>.() -> AutoDiffValue<T>,
+): DerivationResult<T> {
+    contract { callsInPlace(body, InvocationKind.EXACTLY_ONCE) }
+
+    return SimpleAutoDiffField(this, bindings).differentiate(body)
+}
+
+public fun <T : Any, F : Field<T>> F.simpleAutoDiff(
+    vararg bindings: Pair<Symbol, T>,
+    body: SimpleAutoDiffField<T, F>.() -> AutoDiffValue<T>,
+): DerivationResult<T> = simpleAutoDiff(bindings.toMap(), body)
+
+
 /**
  * A constructs that creates a derivative structure with required order on-demand
  */
@@ -247,19 +251,20 @@ public fun <T : Any, F : Field<T>> simpleAutoDiff(field: F): AutoDiffProcessor<T
 // Extensions for differentiation of various basic mathematical functions
 
 // x ^ 2
-public fun <T : Any, F : Field<T>> SimpleAutoDiffField<T, F>.sqr(x: AutoDiffValue<T>): AutoDiffValue<T> =
-    derive(const { x.value * x.value }) { z -> x.d += z.d * 2 * x.value }
+public fun <T : Any, F : ExtendedField<T>> SimpleAutoDiffField<T, F>.sqr(x: AutoDiffValue<T>): AutoDiffValue<T> =
+    derive(const { x.value * x.value }) { z -> x.d += z.d * 2.0 * x.value }
 
 // x ^ 1/2
 public fun <T : Any, F : ExtendedField<T>> SimpleAutoDiffField<T, F>.sqrt(x: AutoDiffValue<T>): AutoDiffValue<T> =
-    derive(const { sqrt(x.value) }) { z -> x.d += z.d * 0.5 / z.value }
+    derive(const { sqrt(x.value) }) { z -> x.d += z.d / 2.0 / z.value }
 
 // x ^ y (const)
 public fun <T : Any, F : ExtendedField<T>> SimpleAutoDiffField<T, F>.pow(
     x: AutoDiffValue<T>,
     y: Double,
-): AutoDiffValue<T> =
-    derive(const { power(x.value, y) }) { z -> x.d += z.d * y * power(x.value, y - 1) }
+): AutoDiffValue<T> = derive(const { power(x.value, y) }) { z ->
+    x.d += z.d * y * power(x.value, y - 1)
+}
 
 public fun <T : Any, F : ExtendedField<T>> SimpleAutoDiffField<T, F>.pow(
     x: AutoDiffValue<T>,
@@ -328,7 +333,13 @@ public fun <T : Any, F : ExtendedField<T>> SimpleAutoDiffField<T, F>.atanh(x: Au
 public class SimpleAutoDiffExtendedField<T : Any, F : ExtendedField<T>>(
     context: F,
     bindings: Map<Symbol, T>,
-) : ExtendedField<AutoDiffValue<T>>, SimpleAutoDiffField<T, F>(context, bindings) {
+) : ExtendedField<AutoDiffValue<T>>, ScaleOperations<AutoDiffValue<T>>,
+    SimpleAutoDiffField<T, F>(context, bindings) {
+
+    override fun number(value: Number): AutoDiffValue<T> = const { number(value) }
+
+    override fun scale(a: AutoDiffValue<T>, value: Double): AutoDiffValue<T> = a * number(value)
+
     // x ^ 2
     public fun sqr(x: AutoDiffValue<T>): AutoDiffValue<T> =
         (this as SimpleAutoDiffField<T, F>).sqr(x)
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/BufferMatrix.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/BufferMatrix.kt
index f8f7f5a05..ef1d82795 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/BufferMatrix.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/BufferMatrix.kt
@@ -78,12 +78,12 @@ public class BufferMatrixContext<T : Any, R : Ring<T>>(
         }
     }
 
-    override fun multiply(a: Matrix<T>, k: Number): BufferMatrix<T> {
-        val aBufferMatrix = a.toBufferMatrix()
-        return elementContext {
-            produce(a.rowNum, a.colNum) { i, j -> aBufferMatrix[i, j] * k.toDouble() }
-        }
-    }
+//    override fun multiply(a: Matrix<T>, k: Number): BufferMatrix<T> {
+//        val aBufferMatrix = a.toBufferMatrix()
+//        return elementContext {
+//            produce(a.rowNum, a.colNum) { i, j -> aBufferMatrix[i, j] * k.toDouble() }
+//        }
+//    }
 
     public companion object
 }
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixContext.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixContext.kt
index c999a170c..639d77e85 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixContext.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixContext.kt
@@ -1,10 +1,7 @@
 package space.kscience.kmath.linear
 
 import space.kscience.kmath.misc.UnstableKMathAPI
-import space.kscience.kmath.operations.Ring
-import space.kscience.kmath.operations.SpaceOperations
-import space.kscience.kmath.operations.invoke
-import space.kscience.kmath.operations.sum
+import space.kscience.kmath.operations.*
 import space.kscience.kmath.structures.Buffer
 import space.kscience.kmath.structures.BufferFactory
 import space.kscience.kmath.structures.asSequence
@@ -167,9 +164,9 @@ public interface GenericMatrixContext<T : Any, R : Ring<T>, out M : Matrix<T>> :
 
         return produce(rowNum, colNum) { i, j -> elementContext { get(i, j) + b[i, j] } }
     }
-
-    public override fun multiply(a: Matrix<T>, k: Number): M =
-        produce(a.rowNum, a.colNum) { i, j -> elementContext { a[i, j] * k } }
+//
+//    public override fun multiply(a: Matrix<T>, k: Number): M =
+//        produce(a.rowNum, a.colNum) { i, j -> elementContext { a[i, j] * k } }
 
     public override operator fun Matrix<T>.times(value: T): M =
         produce(rowNum, colNum) { i, j -> elementContext { get(i, j) * value } }
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/RealMatrixContext.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/RealMatrixContext.kt
index 5f28e6f4c..a53f0837f 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/RealMatrixContext.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/RealMatrixContext.kt
@@ -21,6 +21,8 @@ public object RealMatrixContext : MatrixContext<Double, BufferMatrix<Double>> {
         if (i == j) 1.0 else 0.0
     } + DiagonalFeature
 
+    override fun Matrix<Double>.unaryMinus(): Matrix<Double> = produce(rowNum, colNum) { i, j -> -get(i, j) }
+
     public override infix fun Matrix<Double>.dot(other: Matrix<Double>): BufferMatrix<Double> {
         require(colNum == other.rowNum) { "Matrix dot operation dimension mismatch: ($rowNum, $colNum) x (${other.rowNum}, ${other.colNum})" }
         val bufferMatrix = toBufferMatrix()
@@ -60,12 +62,16 @@ public object RealMatrixContext : MatrixContext<Double, BufferMatrix<Double>> {
         val bufferMatrix = toBufferMatrix()
         return produce(rowNum, colNum) { i, j -> bufferMatrix[i, j] * value }
     }
-
-
-    override fun multiply(a: Matrix<Double>, k: Number): BufferMatrix<Double> {
-        val aBufferMatrix = a.toBufferMatrix()
-        return produce(a.rowNum, a.colNum) { i, j -> aBufferMatrix[i, j] * k.toDouble() }
-    }
+//
+//    override fun multiply(a: Matrix<Double>, k: Number): BufferMatrix<Double> {
+//        val aBufferMatrix = a.toBufferMatrix()
+//        return produce(a.rowNum, a.colNum) { i, j -> aBufferMatrix[i, j] * k.toDouble() }
+//    }
+//
+//    override fun divide(a: Matrix<Double>, k: Number): BufferMatrix<Double> {
+//        val aBufferMatrix = a.toBufferMatrix()
+//        return produce(a.rowNum, a.colNum) { i, j -> aBufferMatrix[i, j] / k.toDouble() }
+//    }
 }
 
 
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/VectorSpace.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/VectorSpace.kt
index 310c1350c..fd3144d24 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/VectorSpace.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/VectorSpace.kt
@@ -1,6 +1,7 @@
 package space.kscience.kmath.linear
 
 import space.kscience.kmath.operations.RealField
+import space.kscience.kmath.operations.Ring
 import space.kscience.kmath.operations.Space
 import space.kscience.kmath.operations.invoke
 import space.kscience.kmath.structures.Buffer
@@ -10,21 +11,18 @@ import space.kscience.kmath.structures.BufferFactory
  * A linear space for vectors.
  * Could be used on any point-like structure
  */
-public interface VectorSpace<T : Any, S : Space<T>> : Space<Point<T>> {
+public interface VectorSpace<T : Any, A : Ring<T>> : Space<Point<T>> {
     public val size: Int
-    public val space: S
-    override val zero: Point<T> get() = produce { space.zero }
+    public val algebra: A
+    override val zero: Point<T> get() = produce { algebra.zero }
 
-    public fun produce(initializer: S.(Int) -> T): Point<T>
+    public fun produce(initializer: A.(Int) -> T): Point<T>
 
-    /**
-     * Produce a space-element of this vector space for expressions
-     */
-    //fun produceElement(initializer: (Int) -> T): Vector<T, S>
+    override fun add(a: Point<T>, b: Point<T>): Point<T> = produce { algebra { a[it] + b[it] } }
 
-    override fun add(a: Point<T>, b: Point<T>): Point<T> = produce { space { a[it] + b[it] } }
+    public fun scale(a: Point<T>, scale: T): Point<T> = produce { algebra { a[it] * scale } }
 
-    override fun multiply(a: Point<T>, k: Number): Point<T> = produce { space { a[it] * k } }
+    override fun Point<T>.unaryMinus(): Point<T> = produce { -get(it) }
 
     //TODO add basis
 
@@ -45,26 +43,25 @@ public interface VectorSpace<T : Any, S : Space<T>> : Space<Point<T>> {
         /**
          * A structured vector space with custom buffer
          */
-        public fun <T : Any, S : Space<T>> buffered(
+        public fun <T : Any, A : Ring<T>> buffered(
             size: Int,
-            space: S,
+            space: A,
             bufferFactory: BufferFactory<T> = Buffer.Companion::boxing,
-        ): BufferVectorSpace<T, S> = BufferVectorSpace(size, space, bufferFactory)
+        ): BufferVectorSpace<T, A> = BufferVectorSpace(size, space, bufferFactory)
 
         /**
          * Automatic buffered vector, unboxed if it is possible
          */
-        public inline fun <reified T : Any, S : Space<T>> auto(size: Int, space: S): VectorSpace<T, S> =
+        public inline fun <reified T : Any, A : Ring<T>> auto(size: Int, space: A): VectorSpace<T, A> =
             buffered(size, space, Buffer.Companion::auto)
     }
 }
 
 
-public class BufferVectorSpace<T : Any, S : Space<T>>(
+public class BufferVectorSpace<T : Any, A : Ring<T>>(
     override val size: Int,
-    override val space: S,
+    override val algebra: A,
     public val bufferFactory: BufferFactory<T>,
-) : VectorSpace<T, S> {
-    override fun produce(initializer: S.(Int) -> T): Buffer<T> = bufferFactory(size) { space.initializer(it) }
-    //override fun produceElement(initializer: (Int) -> T): Vector<T, S> = BufferVector(this, produce(initializer))
+) : VectorSpace<T, A> {
+    override fun produce(initializer: A.(Int) -> T): Buffer<T> = bufferFactory(size) { algebra.initializer(it) }
 }
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/BufferNDAlgebra.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/BufferNDAlgebra.kt
index 71c7d444c..ff9c911ac 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/BufferNDAlgebra.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/BufferNDAlgebra.kt
@@ -1,19 +1,16 @@
 package space.kscience.kmath.nd
 
-import space.kscience.kmath.operations.Field
-import space.kscience.kmath.operations.RealField
-import space.kscience.kmath.operations.Ring
-import space.kscience.kmath.operations.Space
+import space.kscience.kmath.operations.*
 import space.kscience.kmath.structures.Buffer
 import space.kscience.kmath.structures.BufferFactory
 import kotlin.contracts.InvocationKind
 import kotlin.contracts.contract
 
-public interface BufferNDAlgebra<T, C> : NDAlgebra<T, C> {
+public interface BufferNDAlgebra<T, A : Algebra<T>> : NDAlgebra<T, A> {
     public val strides: Strides
     public val bufferFactory: BufferFactory<T>
 
-    override fun produce(initializer: C.(IntArray) -> T): NDBuffer<T> = NDBuffer(
+    override fun produce(initializer: A.(IntArray) -> T): NDBuffer<T> = NDBuffer(
         strides,
         bufferFactory(strides.linearSize) { offset ->
             elementContext.initializer(strides.index(offset))
@@ -30,14 +27,14 @@ public interface BufferNDAlgebra<T, C> : NDAlgebra<T, C> {
             else -> bufferFactory(strides.linearSize) { offset -> get(strides.index(offset)) }
         }
 
-    override fun NDStructure<T>.map(transform: C.(T) -> T): NDBuffer<T> {
+    override fun NDStructure<T>.map(transform: A.(T) -> T): NDBuffer<T> {
         val buffer = bufferFactory(strides.linearSize) { offset ->
             elementContext.transform(buffer[offset])
         }
         return NDBuffer(strides, buffer)
     }
 
-    override fun NDStructure<T>.mapIndexed(transform: C.(index: IntArray, T) -> T): NDBuffer<T> {
+    override fun NDStructure<T>.mapIndexed(transform: A.(index: IntArray, T) -> T): NDBuffer<T> {
         val buffer = bufferFactory(strides.linearSize) { offset ->
             elementContext.transform(
                 strides.index(offset),
@@ -47,7 +44,7 @@ public interface BufferNDAlgebra<T, C> : NDAlgebra<T, C> {
         return NDBuffer(strides, buffer)
     }
 
-    override fun combine(a: NDStructure<T>, b: NDStructure<T>, transform: C.(T, T) -> T): NDBuffer<T> {
+    override fun combine(a: NDStructure<T>, b: NDStructure<T>, transform: A.(T, T) -> T): NDBuffer<T> {
         val buffer = bufferFactory(strides.linearSize) { offset ->
             elementContext.transform(a.buffer[offset], b.buffer[offset])
         }
@@ -55,13 +52,14 @@ public interface BufferNDAlgebra<T, C> : NDAlgebra<T, C> {
     }
 }
 
-public open class BufferedNDSpace<T, R : Space<T>>(
+public open class BufferedNDSpace<T, A : Space<T>>(
     final override val shape: IntArray,
-    final override val elementContext: R,
+    final override val elementContext: A,
     final override val bufferFactory: BufferFactory<T>,
-) : NDSpace<T, R>, BufferNDAlgebra<T, R> {
+) : NDSpace<T, A>, BufferNDAlgebra<T, A> {
     override val strides: Strides = DefaultStrides(shape)
     override val zero: NDBuffer<T> by lazy { produce { zero } }
+    override fun NDStructure<T>.unaryMinus(): NDStructure<T> = produce { -get(it) }
 }
 
 public open class BufferedNDRing<T, R : Ring<T>>(
@@ -76,7 +74,10 @@ public open class BufferedNDField<T, R : Field<T>>(
     shape: IntArray,
     elementContext: R,
     bufferFactory: BufferFactory<T>,
-) : BufferedNDRing<T, R>(shape, elementContext, bufferFactory), NDField<T, R>
+) : BufferedNDRing<T, R>(shape, elementContext, bufferFactory), NDField<T, R> {
+
+    override fun scale(a: NDStructure<T>, value: Double): NDStructure<T> = a.map { it * value }
+}
 
 // space factories
 public fun <T, A : Space<T>> NDAlgebra.Companion.space(
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/NDAlgebra.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/NDAlgebra.kt
index af154d3cd..6b6e887dc 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/NDAlgebra.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/NDAlgebra.kt
@@ -1,8 +1,6 @@
 package space.kscience.kmath.nd
 
-import space.kscience.kmath.operations.Field
-import space.kscience.kmath.operations.Ring
-import space.kscience.kmath.operations.Space
+import space.kscience.kmath.operations.*
 import space.kscience.kmath.structures.*
 
 /**
@@ -21,7 +19,7 @@ public class ShapeMismatchException(public val expected: IntArray, public val ac
  * @param C the type of the element context.
  * @param N the type of the structure.
  */
-public interface NDAlgebra<T, C> {
+public interface NDAlgebra<T, C: Algebra<T>> {
     /**
      * The shape of ND-structures this algebra operates on.
      */
@@ -33,7 +31,7 @@ public interface NDAlgebra<T, C> {
     public val elementContext: C
 
     /**
-     * Produces a new [N] structure using given initializer function.
+     * Produces a new NDStructure using given initializer function.
      */
     public fun produce(initializer: C.(IntArray) -> T): NDStructure<T>
 
@@ -67,7 +65,7 @@ public interface NDAlgebra<T, C> {
  * @param structures the structures to check.
  * @return the array of valid structures.
  */
-internal fun <T, C> NDAlgebra<T, C>.checkShape(vararg structures: NDStructure<T>): Array<out NDStructure<T>> = structures
+internal fun <T, C: Algebra<T>> NDAlgebra<T, C>.checkShape(vararg structures: NDStructure<T>): Array<out NDStructure<T>> = structures
     .map(NDStructure<T>::shape)
     .singleOrNull { !shape.contentEquals(it) }
     ?.let<IntArray, Array<out NDStructure<T>>> { throw ShapeMismatchException(shape, it) }
@@ -79,7 +77,7 @@ internal fun <T, C> NDAlgebra<T, C>.checkShape(vararg structures: NDStructure<T>
  * @param element the structure to check.
  * @return the valid structure.
  */
-internal fun <T, C> NDAlgebra<T, C>.checkShape(element: NDStructure<T>): NDStructure<T> {
+internal fun <T, C: Algebra<T>> NDAlgebra<T, C>.checkShape(element: NDStructure<T>): NDStructure<T> {
     if (!element.shape.contentEquals(shape)) throw ShapeMismatchException(shape, element.shape)
     return element
 }
@@ -102,14 +100,14 @@ public interface NDSpace<T, S : Space<T>> : Space<NDStructure<T>>, NDAlgebra<T,
     public override fun add(a: NDStructure<T>, b: NDStructure<T>): NDStructure<T> =
         combine(a, b) { aValue, bValue -> add(aValue, bValue) }
 
-    /**
-     * Element-wise multiplication by scalar.
-     *
-     * @param a the multiplicand.
-     * @param k the multiplier.
-     * @return the product.
-     */
-    public override fun multiply(a: NDStructure<T>, k: Number): NDStructure<T> = a.map() { multiply(it, k) }
+//    /**
+//     * Element-wise multiplication by scalar.
+//     *
+//     * @param a the multiplicand.
+//     * @param k the multiplier.
+//     * @return the product.
+//     */
+//    public override fun multiply(a: NDStructure<T>, k: Number): NDStructure<T> =  a.map { multiply(it, k) }
 
     // TODO move to extensions after KEEP-176
 
@@ -120,7 +118,7 @@ public interface NDSpace<T, S : Space<T>> : Space<NDStructure<T>>, NDAlgebra<T,
      * @param arg the augend.
      * @return the sum.
      */
-    public operator fun NDStructure<T>.plus(arg: T): NDStructure<T> = this.map() { value -> add(arg, value) }
+    public operator fun NDStructure<T>.plus(arg: T): NDStructure<T> = this.map { value -> add(arg, value) }
 
     /**
      * Subtracts an element from ND structure of it.
@@ -200,7 +198,7 @@ public interface NDRing<T, R : Ring<T>> : Ring<NDStructure<T>>, NDSpace<T, R> {
  * @param N the type of ND structure.
  * @param F the type field of structure elements.
  */
-public interface NDField<T, F : Field<T>> : Field<NDStructure<T>>, NDRing<T, F> {
+public interface NDField<T, F : Field<T>> : Field<NDStructure<T>>, NDRing<T, F>, ScaleOperations<NDStructure<T>> {
     /**
      * Element-wise division.
      *
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/RealNDField.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/RealNDField.kt
index 73ba337ae..2165aea22 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/RealNDField.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/RealNDField.kt
@@ -2,8 +2,9 @@ package space.kscience.kmath.nd
 
 import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.operations.ExtendedField
+import space.kscience.kmath.operations.NumbersAddOperations
 import space.kscience.kmath.operations.RealField
-import space.kscience.kmath.operations.RingWithNumbers
+import space.kscience.kmath.operations.ScaleOperations
 import space.kscience.kmath.structures.Buffer
 import space.kscience.kmath.structures.RealBuffer
 import kotlin.contracts.InvocationKind
@@ -13,7 +14,8 @@ import kotlin.contracts.contract
 public class RealNDField(
     shape: IntArray,
 ) : BufferedNDField<Double, RealField>(shape, RealField, Buffer.Companion::real),
-    RingWithNumbers<NDStructure<Double>>,
+    NumbersAddOperations<NDStructure<Double>>,
+    ScaleOperations<NDStructure<Double>>,
     ExtendedField<NDStructure<Double>> {
 
     override val zero: NDBuffer<Double> by lazy { produce { zero } }
@@ -75,6 +77,8 @@ public class RealNDField(
         return NDBuffer(strides, buffer)
     }
 
+    override fun scale(a: NDStructure<Double>, value: Double): NDStructure<Double> = a.map { it * value }
+
     override fun power(arg: NDStructure<Double>, pow: Number): NDBuffer<Double> = arg.map { power(it, pow) }
 
     override fun exp(arg: NDStructure<Double>): NDBuffer<Double> = arg.map { exp(it) }
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/ShortNDRing.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/ShortNDRing.kt
index 30960a090..2085840a4 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/ShortNDRing.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/ShortNDRing.kt
@@ -1,7 +1,7 @@
 package space.kscience.kmath.nd
 
 import space.kscience.kmath.misc.UnstableKMathAPI
-import space.kscience.kmath.operations.RingWithNumbers
+import space.kscience.kmath.operations.NumbersAddOperations
 import space.kscience.kmath.operations.ShortRing
 import space.kscience.kmath.structures.Buffer
 import space.kscience.kmath.structures.ShortBuffer
@@ -12,7 +12,7 @@ import kotlin.contracts.contract
 public class ShortNDRing(
     shape: IntArray,
 ) : BufferedNDRing<Short, ShortRing>(shape, ShortRing, Buffer.Companion::auto),
-    RingWithNumbers<NDStructure<Short>> {
+    NumbersAddOperations<NDStructure<Short>> {
 
     override val zero: NDBuffer<Short> by lazy { produce { zero } }
     override val one: NDBuffer<Short> by lazy { produce { one } }
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/Algebra.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/Algebra.kt
index 572f7089a..2163f61b2 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/Algebra.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/Algebra.kt
@@ -87,10 +87,11 @@ public interface Algebra<T> {
      * @param right the second argument of operation.
      * @return a result of operation.
      */
-    public fun binaryOperation(operation: String, left: T, right: T): T = binaryOperationFunction(operation)(left, right)
+    public fun binaryOperation(operation: String, left: T, right: T): T =
+        binaryOperationFunction(operation)(left, right)
 }
 
-public fun <T: Any> Algebra<T>.bindSymbol(symbol: Symbol): T = bindSymbol(symbol.identity)
+public fun <T : Any> Algebra<T>.bindSymbol(symbol: Symbol): T = bindSymbol(symbol.identity)
 
 /**
  * Call a block with an [Algebra] as receiver.
@@ -114,15 +115,6 @@ public interface SpaceOperations<T> : Algebra<T> {
      */
     public fun add(a: T, b: T): T
 
-    /**
-     * Multiplication of element by scalar.
-     *
-     * @param a the multiplier.
-     * @param k the multiplicand.
-     * @return the produce.
-     */
-    public fun multiply(a: T, k: Number): T
-
     // Operations to be performed in this context. Could be moved to extensions in case of KEEP-176
 
     /**
@@ -131,7 +123,7 @@ public interface SpaceOperations<T> : Algebra<T> {
      * @receiver this value.
      * @return the additive inverse of this value.
      */
-    public operator fun T.unaryMinus(): T = multiply(this, -1.0)
+    public operator fun T.unaryMinus(): T
 
     /**
      * Returns this value.
@@ -159,34 +151,6 @@ public interface SpaceOperations<T> : Algebra<T> {
      */
     public operator fun T.minus(b: T): T = add(this, -b)
 
-    /**
-     * Multiplication of this element by a scalar.
-     *
-     * @receiver the multiplier.
-     * @param k the multiplicand.
-     * @return the product.
-     */
-    public operator fun T.times(k: Number): T = multiply(this, k)
-
-    /**
-     * Division of this element by scalar.
-     *
-     * @receiver the dividend.
-     * @param k the divisor.
-     * @return the quotient.
-     */
-    @Deprecated("Dividing not allowed in a Ring")
-    public operator fun T.div(k: Number): T = multiply(this, 1.0 / k.toDouble())
-
-    /**
-     * Multiplication of this number by element.
-     *
-     * @receiver the multiplier.
-     * @param b the multiplicand.
-     * @return the product.
-     */
-    public operator fun Number.times(b: T): T = b * this
-
     public override fun unaryOperationFunction(operation: String): (arg: T) -> T = when (operation) {
         PLUS_OPERATION -> { arg -> arg }
         MINUS_OPERATION -> { arg -> -arg }
@@ -318,13 +282,6 @@ public interface FieldOperations<T> : RingOperations<T> {
  *
  * @param T the type of element of this semifield.
  */
-public interface Field<T> : Ring<T>, FieldOperations<T> {
-    /**
-     * Division of element by scalar.
-     *
-     * @receiver the dividend.
-     * @param b the divisor.
-     * @return the quotient.
-     */
-    public operator fun Number.div(b: T): T = this * divide(one, b)
-}
+public interface Field<T> : Ring<T>, FieldOperations<T>, ScaleOperations<T>, NumericAlgebra<T> {
+    override fun number(value: Number): T = scale(one, value.toDouble())
+}
\ No newline at end of file
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/AlgebraElements.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/AlgebraElements.kt
index 629c4de1b..1fb4f6750 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/AlgebraElements.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/AlgebraElements.kt
@@ -14,24 +14,24 @@ public interface AlgebraElement<T, C : Algebra<T>> {
      */
     public val context: C
 }
-
-/**
- * Divides this element by number.
- *
- * @param k the divisor.
- * @return the quotient.
- */
-public operator fun <T : AlgebraElement<T, S>, S : Space<T>> T.div(k: Number): T =
-    context.multiply(this, 1.0 / k.toDouble())
-
-/**
- * Multiplies this element by number.
- *
- * @param k the multiplicand.
- * @return the product.
- */
-public operator fun <T : AlgebraElement<T, S>, S : Space<T>> T.times(k: Number): T =
-    context.multiply(this, k.toDouble())
+//
+///**
+// * Divides this element by number.
+// *
+// * @param k the divisor.
+// * @return the quotient.
+// */
+//public operator fun <T : AlgebraElement<T, S>, S : Space<T>> T.div(k: Number): T =
+//    context.multiply(this, 1.0 / k.toDouble())
+//
+///**
+// * Multiplies this element by number.
+// *
+// * @param k the multiplicand.
+// * @return the product.
+// */
+//public operator fun <T : AlgebraElement<T, S>, S : Space<T>> T.times(k: Number): T =
+//    context.multiply(this, k.toDouble())
 
 /**
  * Subtracts element from this one.
@@ -39,8 +39,9 @@ public operator fun <T : AlgebraElement<T, S>, S : Space<T>> T.times(k: Number):
  * @param b the subtrahend.
  * @return the difference.
  */
-public operator fun <T : AlgebraElement<T, S>, S : Space<T>> T.minus(b: T): T =
-    context.add(this, context.multiply(b, -1.0))
+@UnstableKMathAPI
+public operator fun <T : AlgebraElement<T, S>, S : NumbersAddOperations<T>> T.minus(b: T): T =
+    context.add(this, context.run { -b})
 
 /**
  * Adds element to this one.
@@ -51,11 +52,11 @@ public operator fun <T : AlgebraElement<T, S>, S : Space<T>> T.minus(b: T): T =
 public operator fun <T : AlgebraElement<T, S>, S : Space<T>> T.plus(b: T): T =
     context.add(this, b)
 
-/**
- * Number times element
- */
-public operator fun <T : AlgebraElement<T, S>, S : Space<T>> Number.times(element: T): T =
-    element.times(this)
+///**
+// * Number times element
+// */
+//public operator fun <T : AlgebraElement<T, S>, S : Space<T>> Number.times(element: T): T =
+//    element.times(this)
 
 
 /**
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/BigInt.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/BigInt.kt
index c21260b82..7e6a2eb81 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/BigInt.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/BigInt.kt
@@ -21,29 +21,28 @@ public typealias TBase = ULong
  * @author Robert Drynkin (https://github.com/robdrynkin) and Peter Klimai (https://github.com/pklimai)
  */
 @OptIn(UnstableKMathAPI::class)
-public object BigIntField : Field<BigInt>, RingWithNumbers<BigInt> {
+public object BigIntField : Field<BigInt>, NumbersAddOperations<BigInt>, ScaleOperations<BigInt> {
     override val zero: BigInt = BigInt.ZERO
     override val one: BigInt = BigInt.ONE
 
-    override fun add(a: BigInt, b: BigInt): BigInt = a.plus(b)
     override fun number(value: Number): BigInt = value.toLong().toBigInt()
 
-    override fun multiply(a: BigInt, k: Number): BigInt = a.times(number(k))
-
+    @Suppress("EXTENSION_SHADOWED_BY_MEMBER")
+    override fun BigInt.unaryMinus(): BigInt = -this
+    override fun add(a: BigInt, b: BigInt): BigInt = a.plus(b)
+    override fun scale(a: BigInt, value: Double): BigInt = a.times(number(value))
     override fun multiply(a: BigInt, b: BigInt): BigInt = a.times(b)
+    override fun divide(a: BigInt, b: BigInt): BigInt = a.div(b)
 
     public operator fun String.unaryPlus(): BigInt = this.parseBigInteger() ?: error("Can't parse $this as big integer")
-
     public operator fun String.unaryMinus(): BigInt =
         -(this.parseBigInteger() ?: error("Can't parse $this as big integer"))
-
-    override fun divide(a: BigInt, b: BigInt): BigInt = a.div(b)
 }
 
 public class BigInt internal constructor(
     private val sign: Byte,
-    private val magnitude: Magnitude
-    ) : Comparable<BigInt> {
+    private val magnitude: Magnitude,
+) : Comparable<BigInt> {
     public override fun compareTo(other: BigInt): Int = when {
         (sign == 0.toByte()) and (other.sign == 0.toByte()) -> 0
         sign < other.sign -> -1
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/NumericAlgebra.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/NumericAlgebra.kt
index 81f4c1fdf..187261b1d 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/NumericAlgebra.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/NumericAlgebra.kt
@@ -81,14 +81,53 @@ public interface NumericAlgebra<T> : Algebra<T> {
         rightSideNumberOperationFunction(operation)(left, right)
 }
 
+/**
+ * Scale by scalar operations
+ */
+public interface ScaleOperations<T> : Algebra<T> {
+    /**
+     * Scaling of element by scalar.
+     *
+     * @param a the multiplier.
+     * @param value the multiplicand.
+     * @return the produce.
+     */
+    public fun scale(a: T, value: Double): T
+
+    /**
+     * Multiplication of this element by a scalar.
+     *
+     * @receiver the multiplier.
+     * @param k the multiplicand.
+     * @return the product.
+     */
+    public operator fun T.times(k: Number): T = scale(this, k.toDouble())
+
+    /**
+     * Division of this element by scalar.
+     *
+     * @receiver the dividend.
+     * @param k the divisor.
+     * @return the quotient.
+     */
+    public operator fun T.div(k: Number): T = scale(this, 1.0 / k.toDouble())
+
+    /**
+     * Multiplication of this number by element.
+     *
+     * @receiver the multiplier.
+     * @param b the multiplicand.
+     * @return the product.
+     */
+    public operator fun Number.times(b: T): T = b * this
+}
+
 /**
  * A combination of [NumericAlgebra] and [Ring] that adds intrinsic simple operations on numbers like `T+1`
  * TODO to be removed and replaced by extensions after multiple receivers are there
  */
 @UnstableKMathAPI
-public interface RingWithNumbers<T>: Ring<T>, NumericAlgebra<T>{
-    public override fun number(value: Number): T = one * value
-
+public interface NumbersAddOperations<T> : Space<T>, NumericAlgebra<T> {
     /**
      * Addition of element and scalar.
      *
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/OptionalOperations.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/OptionalOperations.kt
index 6cb329695..6e6249dfe 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/OptionalOperations.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/OptionalOperations.kt
@@ -107,111 +107,6 @@ public fun <T : AlgebraElement<T, out TrigonometricOperations<T>>> acos(arg: T):
 @UnstableKMathAPI
 public fun <T : AlgebraElement<T, out TrigonometricOperations<T>>> atan(arg: T): T = arg.context.atan(arg)
 
-/**
- * A container for hyperbolic trigonometric operations for specific type.
- *
- * @param T the type of element of this structure.
- */
-public interface HyperbolicOperations<T> : Algebra<T> {
-    /**
-     * Computes the hyperbolic sine of [arg].
-     */
-    public fun sinh(arg: T): T
-
-    /**
-     * Computes the hyperbolic cosine of [arg].
-     */
-    public fun cosh(arg: T): T
-
-    /**
-     * Computes the hyperbolic tangent of [arg].
-     */
-    public fun tanh(arg: T): T
-
-    /**
-     * Computes the inverse hyperbolic sine of [arg].
-     */
-    public fun asinh(arg: T): T
-
-    /**
-     * Computes the inverse hyperbolic cosine of [arg].
-     */
-    public fun acosh(arg: T): T
-
-    /**
-     * Computes the inverse hyperbolic tangent of [arg].
-     */
-    public fun atanh(arg: T): T
-
-    public companion object {
-        /**
-         * The identifier of hyperbolic sine.
-         */
-        public const val SINH_OPERATION: String = "sinh"
-
-        /**
-         * The identifier of hyperbolic cosine.
-         */
-        public const val COSH_OPERATION: String = "cosh"
-
-        /**
-         * The identifier of hyperbolic tangent.
-         */
-        public const val TANH_OPERATION: String = "tanh"
-
-        /**
-         * The identifier of inverse hyperbolic sine.
-         */
-        public const val ASINH_OPERATION: String = "asinh"
-
-        /**
-         * The identifier of inverse hyperbolic cosine.
-         */
-        public const val ACOSH_OPERATION: String = "acosh"
-
-        /**
-         * The identifier of inverse hyperbolic tangent.
-         */
-        public const val ATANH_OPERATION: String = "atanh"
-    }
-}
-
-/**
- * Computes the hyperbolic sine of [arg].
- */
-@UnstableKMathAPI
-public fun <T : AlgebraElement<T, out HyperbolicOperations<T>>> sinh(arg: T): T = arg.context.sinh(arg)
-
-/**
- * Computes the hyperbolic cosine of [arg].
- */
-@UnstableKMathAPI
-public fun <T : AlgebraElement<T, out HyperbolicOperations<T>>> cosh(arg: T): T = arg.context.cosh(arg)
-
-/**
- * Computes the hyperbolic tangent of [arg].
- */
-@UnstableKMathAPI
-public fun <T : AlgebraElement<T, out HyperbolicOperations<T>>> tanh(arg: T): T = arg.context.tanh(arg)
-
-/**
- * Computes the inverse hyperbolic sine of [arg].
- */
-@UnstableKMathAPI
-public fun <T : AlgebraElement<T, out HyperbolicOperations<T>>> asinh(arg: T): T = arg.context.asinh(arg)
-
-/**
- * Computes the inverse hyperbolic cosine of [arg].
- */
-@UnstableKMathAPI
-public fun <T : AlgebraElement<T, out HyperbolicOperations<T>>> acosh(arg: T): T = arg.context.acosh(arg)
-
-/**
- * Computes the inverse hyperbolic tangent of [arg].
- */
-@UnstableKMathAPI
-public fun <T : AlgebraElement<T, out HyperbolicOperations<T>>> atanh(arg: T): T = arg.context.atanh(arg)
-
 /**
  * A context extension to include power operations based on exponentiation.
  *
@@ -284,6 +179,36 @@ public interface ExponentialOperations<T> : Algebra<T> {
      */
     public fun ln(arg: T): T
 
+    /**
+     * Computes the hyperbolic sine of [arg].
+     */
+    public fun sinh(arg: T): T
+
+    /**
+     * Computes the hyperbolic cosine of [arg].
+     */
+    public fun cosh(arg: T): T
+
+    /**
+     * Computes the hyperbolic tangent of [arg].
+     */
+    public fun tanh(arg: T): T
+
+    /**
+     * Computes the inverse hyperbolic sine of [arg].
+     */
+    public fun asinh(arg: T): T
+
+    /**
+     * Computes the inverse hyperbolic cosine of [arg].
+     */
+    public fun acosh(arg: T): T
+
+    /**
+     * Computes the inverse hyperbolic tangent of [arg].
+     */
+    public fun atanh(arg: T): T
+
     public companion object {
         /**
          * The identifier of exponential function.
@@ -294,6 +219,36 @@ public interface ExponentialOperations<T> : Algebra<T> {
          * The identifier of natural logarithm.
          */
         public const val LN_OPERATION: String = "ln"
+
+        /**
+         * The identifier of hyperbolic sine.
+         */
+        public const val SINH_OPERATION: String = "sinh"
+
+        /**
+         * The identifier of hyperbolic cosine.
+         */
+        public const val COSH_OPERATION: String = "cosh"
+
+        /**
+         * The identifier of hyperbolic tangent.
+         */
+        public const val TANH_OPERATION: String = "tanh"
+
+        /**
+         * The identifier of inverse hyperbolic sine.
+         */
+        public const val ASINH_OPERATION: String = "asinh"
+
+        /**
+         * The identifier of inverse hyperbolic cosine.
+         */
+        public const val ACOSH_OPERATION: String = "acosh"
+
+        /**
+         * The identifier of inverse hyperbolic tangent.
+         */
+        public const val ATANH_OPERATION: String = "atanh"
     }
 }
 
@@ -309,6 +264,43 @@ public fun <T : AlgebraElement<T, out ExponentialOperations<T>>> exp(arg: T): T
 @UnstableKMathAPI
 public fun <T : AlgebraElement<T, out ExponentialOperations<T>>> ln(arg: T): T = arg.context.ln(arg)
 
+
+/**
+ * Computes the hyperbolic sine of [arg].
+ */
+@UnstableKMathAPI
+public fun <T : AlgebraElement<T, out ExponentialOperations<T>>> sinh(arg: T): T = arg.context.sinh(arg)
+
+/**
+ * Computes the hyperbolic cosine of [arg].
+ */
+@UnstableKMathAPI
+public fun <T : AlgebraElement<T, out ExponentialOperations<T>>> cosh(arg: T): T = arg.context.cosh(arg)
+
+/**
+ * Computes the hyperbolic tangent of [arg].
+ */
+@UnstableKMathAPI
+public fun <T : AlgebraElement<T, out ExponentialOperations<T>>> tanh(arg: T): T = arg.context.tanh(arg)
+
+/**
+ * Computes the inverse hyperbolic sine of [arg].
+ */
+@UnstableKMathAPI
+public fun <T : AlgebraElement<T, out ExponentialOperations<T>>> asinh(arg: T): T = arg.context.asinh(arg)
+
+/**
+ * Computes the inverse hyperbolic cosine of [arg].
+ */
+@UnstableKMathAPI
+public fun <T : AlgebraElement<T, out ExponentialOperations<T>>> acosh(arg: T): T = arg.context.acosh(arg)
+
+/**
+ * Computes the inverse hyperbolic tangent of [arg].
+ */
+@UnstableKMathAPI
+public fun <T : AlgebraElement<T, out ExponentialOperations<T>>> atanh(arg: T): T = arg.context.atanh(arg)
+
 /**
  * A container for norm functional on element.
  *
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/algebraExtensions.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/algebraExtensions.kt
index ae1267d2b..66b16b6f6 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/algebraExtensions.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/algebraExtensions.kt
@@ -26,7 +26,8 @@ public fun <T> Space<T>.sum(data: Sequence<T>): T = data.fold(zero) { left, righ
  * @return the average value.
  * @author Iaroslav Postovalov
  */
-public fun <T> Space<T>.average(data: Iterable<T>): T = sum(data) / data.count()
+public fun <T, S> S.average(data: Iterable<T>): T where S : Space<T>, S : ScaleOperations<T> =
+    sum(data) / data.count()
 
 /**
  * Returns an average value of elements in the sequence in this [Space].
@@ -36,7 +37,8 @@ public fun <T> Space<T>.average(data: Iterable<T>): T = sum(data) / data.count()
  * @return the average value.
  * @author Iaroslav Postovalov
  */
-public fun <T> Space<T>.average(data: Sequence<T>): T = sum(data) / data.count()
+public fun <T, S> S.average(data: Sequence<T>): T where S : Space<T>, S : ScaleOperations<T> =
+    sum(data) / data.count()
 
 /**
  * Absolute of the comparable [value]
@@ -69,7 +71,8 @@ public fun <T> Sequence<T>.sumWith(space: Space<T>): T = space.sum(this)
  * @return the average value.
  * @author Iaroslav Postovalov
  */
-public fun <T> Iterable<T>.averageWith(space: Space<T>): T = space.average(this)
+public fun <T, S> Iterable<T>.averageWith(space: S): T  where S : Space<T>, S : ScaleOperations<T>  =
+    space.average(this)
 
 /**
  * Returns an average value of elements in the sequence in this [Space].
@@ -79,7 +82,8 @@ public fun <T> Iterable<T>.averageWith(space: Space<T>): T = space.average(this)
  * @return the average value.
  * @author Iaroslav Postovalov
  */
-public fun <T> Sequence<T>.averageWith(space: Space<T>): T = space.average(this)
+public fun <T, S> Sequence<T>.averageWith(space: S): T  where S : Space<T>, S : ScaleOperations<T>  =
+    space.average(this)
 
 //TODO optimized power operation
 
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/numbers.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/numbers.kt
index aa62715d1..4841e78d6 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/numbers.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/numbers.kt
@@ -8,7 +8,6 @@ import kotlin.math.pow as kpow
 public interface ExtendedFieldOperations<T> :
     FieldOperations<T>,
     TrigonometricOperations<T>,
-    HyperbolicOperations<T>,
     PowerOperations<T>,
     ExponentialOperations<T> {
     public override fun tan(arg: T): T = sin(arg) / cos(arg)
@@ -21,15 +20,15 @@ public interface ExtendedFieldOperations<T> :
         TrigonometricOperations.ACOS_OPERATION -> ::acos
         TrigonometricOperations.ASIN_OPERATION -> ::asin
         TrigonometricOperations.ATAN_OPERATION -> ::atan
-        HyperbolicOperations.COSH_OPERATION -> ::cosh
-        HyperbolicOperations.SINH_OPERATION -> ::sinh
-        HyperbolicOperations.TANH_OPERATION -> ::tanh
-        HyperbolicOperations.ACOSH_OPERATION -> ::acosh
-        HyperbolicOperations.ASINH_OPERATION -> ::asinh
-        HyperbolicOperations.ATANH_OPERATION -> ::atanh
         PowerOperations.SQRT_OPERATION -> ::sqrt
         ExponentialOperations.EXP_OPERATION -> ::exp
         ExponentialOperations.LN_OPERATION -> ::ln
+        ExponentialOperations.COSH_OPERATION -> ::cosh
+        ExponentialOperations.SINH_OPERATION -> ::sinh
+        ExponentialOperations.TANH_OPERATION -> ::tanh
+        ExponentialOperations.ACOSH_OPERATION -> ::acosh
+        ExponentialOperations.ASINH_OPERATION -> ::asinh
+        ExponentialOperations.ATANH_OPERATION -> ::atanh
         else -> super<FieldOperations>.unaryOperationFunction(operation)
     }
 }
@@ -37,18 +36,18 @@ public interface ExtendedFieldOperations<T> :
 /**
  * Advanced Number-like field that implements basic operations.
  */
-public interface ExtendedField<T> : ExtendedFieldOperations<T>, Field<T>, NumericAlgebra<T> {
-    public override fun sinh(arg: T): T = (exp(arg) - exp(-arg)) / 2
-    public override fun cosh(arg: T): T = (exp(arg) + exp(-arg)) / 2
+public interface ExtendedField<T> : ExtendedFieldOperations<T>, Field<T>, NumericAlgebra<T>, ScaleOperations<T> {
+    public override fun sinh(arg: T): T = (exp(arg) - exp(-arg)) / 2.0
+    public override fun cosh(arg: T): T = (exp(arg) + exp(-arg)) / 2.0
     public override fun tanh(arg: T): T = (exp(arg) - exp(-arg)) / (exp(-arg) + exp(arg))
     public override fun asinh(arg: T): T = ln(sqrt(arg * arg + one) + arg)
     public override fun acosh(arg: T): T = ln(arg + sqrt((arg - one) * (arg + one)))
-    public override fun atanh(arg: T): T = (ln(arg + one) - ln(one - arg)) / 2
+    public override fun atanh(arg: T): T = (ln(arg + one) - ln(one - arg)) / 2.0
 
     public override fun rightSideNumberOperationFunction(operation: String): (left: T, right: Number) -> T =
         when (operation) {
             PowerOperations.POW_OPERATION -> ::power
-            else -> super.rightSideNumberOperationFunction(operation)
+            else -> super<Field>.rightSideNumberOperationFunction(operation)
         }
 }
 
@@ -56,28 +55,27 @@ public interface ExtendedField<T> : ExtendedFieldOperations<T>, Field<T>, Numeri
  * A field for [Double] without boxing. Does not produce appropriate field element.
  */
 @Suppress("EXTENSION_SHADOWED_BY_MEMBER", "OVERRIDE_BY_INLINE", "NOTHING_TO_INLINE")
-public object RealField : ExtendedField<Double>, Norm<Double, Double> {
-    public override val zero: Double
-        get() = 0.0
-
-    public override val one: Double
-        get() = 1.0
+public object RealField : ExtendedField<Double>, Norm<Double, Double>, ScaleOperations<Double> {
+    public override val zero: Double = 0.0
+    public override val one: Double = 1.0
 
     override fun number(value: Number): Double = value.toDouble()
 
     public override fun binaryOperationFunction(operation: String): (left: Double, right: Double) -> Double =
         when (operation) {
             PowerOperations.POW_OPERATION -> ::power
-            else -> super.binaryOperationFunction(operation)
+            else -> super<ExtendedField>.binaryOperationFunction(operation)
         }
 
     public override inline fun add(a: Double, b: Double): Double = a + b
-    public override inline fun multiply(a: Double, k: Number): Double = a * k.toDouble()
+//    public override inline fun multiply(a: Double, k: Number): Double = a * k.toDouble()
+//    override fun divide(a: Double, k: Number): Double = a / k.toDouble()
 
     public override inline fun multiply(a: Double, b: Double): Double = a * b
-
     public override inline fun divide(a: Double, b: Double): Double = a / b
 
+    override fun scale(a: Double, value: Double): Double = a * value
+
     public override inline fun sin(arg: Double): Double = kotlin.math.sin(arg)
     public override inline fun cos(arg: Double): Double = kotlin.math.cos(arg)
     public override inline fun tan(arg: Double): Double = kotlin.math.tan(arg)
@@ -110,11 +108,8 @@ public object RealField : ExtendedField<Double>, Norm<Double, Double> {
  */
 @Suppress("EXTENSION_SHADOWED_BY_MEMBER", "OVERRIDE_BY_INLINE", "NOTHING_TO_INLINE")
 public object FloatField : ExtendedField<Float>, Norm<Float, Float> {
-    public override val zero: Float
-        get() = 0.0f
-
-    public override val one: Float
-        get() = 1.0f
+    public override val zero: Float = 0.0f
+    public override val one: Float = 1.0f
 
     override fun number(value: Number): Float = value.toFloat()
 
@@ -125,7 +120,7 @@ public object FloatField : ExtendedField<Float>, Norm<Float, Float> {
         }
 
     public override inline fun add(a: Float, b: Float): Float = a + b
-    public override inline fun multiply(a: Float, k: Number): Float = a * k.toFloat()
+    override fun scale(a: Float, value: Double): Float = a * value.toFloat()
 
     public override inline fun multiply(a: Float, b: Float): Float = a * b
 
@@ -170,12 +165,8 @@ public object IntRing : Ring<Int>, Norm<Int, Int>, NumericAlgebra<Int> {
         get() = 1
 
     override fun number(value: Number): Int = value.toInt()
-
     public override inline fun add(a: Int, b: Int): Int = a + b
-    public override inline fun multiply(a: Int, k: Number): Int = k.toInt() * a
-
     public override inline fun multiply(a: Int, b: Int): Int = a * b
-
     public override inline fun norm(arg: Int): Int = abs(arg)
 
     public override inline fun Int.unaryMinus(): Int = -this
@@ -196,12 +187,8 @@ public object ShortRing : Ring<Short>, Norm<Short, Short>, NumericAlgebra<Short>
         get() = 1
 
     override fun number(value: Number): Short = value.toShort()
-
     public override inline fun add(a: Short, b: Short): Short = (a + b).toShort()
-    public override inline fun multiply(a: Short, k: Number): Short = (a * k.toShort()).toShort()
-
     public override inline fun multiply(a: Short, b: Short): Short = (a * b).toShort()
-
     public override fun norm(arg: Short): Short = if (arg > 0) arg else (-arg).toShort()
 
     public override inline fun Short.unaryMinus(): Short = (-this).toShort()
@@ -222,12 +209,8 @@ public object ByteRing : Ring<Byte>, Norm<Byte, Byte>, NumericAlgebra<Byte> {
         get() = 1
 
     override fun number(value: Number): Byte = value.toByte()
-
     public override inline fun add(a: Byte, b: Byte): Byte = (a + b).toByte()
-    public override inline fun multiply(a: Byte, k: Number): Byte = (a * k.toByte()).toByte()
-
     public override inline fun multiply(a: Byte, b: Byte): Byte = (a * b).toByte()
-
     public override fun norm(arg: Byte): Byte = if (arg > 0) arg else (-arg).toByte()
 
     public override inline fun Byte.unaryMinus(): Byte = (-this).toByte()
@@ -248,12 +231,8 @@ public object LongRing : Ring<Long>, Norm<Long, Long>, NumericAlgebra<Long> {
         get() = 1L
 
     override fun number(value: Number): Long = value.toLong()
-
     public override inline fun add(a: Long, b: Long): Long = a + b
-    public override inline fun multiply(a: Long, k: Number): Long = a * k.toLong()
-
     public override inline fun multiply(a: Long, b: Long): Long = a * b
-
     public override fun norm(arg: Long): Long = abs(arg)
 
     public override inline fun Long.unaryMinus(): Long = (-this)
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/RealBufferField.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/RealBufferField.kt
index 7351881ee..2a03a36e3 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/RealBufferField.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/RealBufferField.kt
@@ -8,6 +8,12 @@ import kotlin.math.*
  * [ExtendedFieldOperations] over [RealBuffer].
  */
 public object RealBufferFieldOperations : ExtendedFieldOperations<Buffer<Double>> {
+    override fun Buffer<Double>.unaryMinus(): RealBuffer = if (this is RealBuffer) {
+        RealBuffer(size) { -array[it] }
+    } else {
+        RealBuffer(size) { -get(it) }
+    }
+
     public override fun add(a: Buffer<Double>, b: Buffer<Double>): RealBuffer {
         require(b.size == a.size) {
             "The size of the first buffer ${a.size} should be the same as for second one: ${b.size} "
@@ -19,15 +25,24 @@ public object RealBufferFieldOperations : ExtendedFieldOperations<Buffer<Double>
             RealBuffer(DoubleArray(a.size) { aArray[it] + bArray[it] })
         } else RealBuffer(DoubleArray(a.size) { a[it] + b[it] })
     }
-
-    public override fun multiply(a: Buffer<Double>, k: Number): RealBuffer {
-        val kValue = k.toDouble()
-
-        return if (a is RealBuffer) {
-            val aArray = a.array
-            RealBuffer(DoubleArray(a.size) { aArray[it] * kValue })
-        } else RealBuffer(DoubleArray(a.size) { a[it] * kValue })
-    }
+//
+//    public override fun multiply(a: Buffer<Double>, k: Number): RealBuffer {
+//        val kValue = k.toDouble()
+//
+//        return if (a is RealBuffer) {
+//            val aArray = a.array
+//            RealBuffer(DoubleArray(a.size) { aArray[it] * kValue })
+//        } else RealBuffer(DoubleArray(a.size) { a[it] * kValue })
+//    }
+//
+//    public override fun divide(a: Buffer<Double>, k: Number): RealBuffer {
+//        val kValue = k.toDouble()
+//
+//        return if (a is RealBuffer) {
+//            val aArray = a.array
+//            RealBuffer(DoubleArray(a.size) { aArray[it] / kValue })
+//        } else RealBuffer(DoubleArray(a.size) { a[it] / kValue })
+//    }
 
     public override fun multiply(a: Buffer<Double>, b: Buffer<Double>): RealBuffer {
         require(b.size == a.size) {
@@ -152,14 +167,22 @@ public class RealBufferField(public val size: Int) : ExtendedField<Buffer<Double
 
     override fun number(value: Number): Buffer<Double> = RealBuffer(size) { value.toDouble() }
 
+    override fun Buffer<Double>.unaryMinus(): Buffer<Double> = RealBufferFieldOperations.run {
+        -this@unaryMinus
+    }
+
     public override fun add(a: Buffer<Double>, b: Buffer<Double>): RealBuffer {
         require(a.size == size) { "The buffer size ${a.size} does not match context size $size" }
         return RealBufferFieldOperations.add(a, b)
     }
 
-    public override fun multiply(a: Buffer<Double>, k: Number): RealBuffer {
+    public override fun scale(a: Buffer<Double>, value: Double): RealBuffer {
         require(a.size == size) { "The buffer size ${a.size} does not match context size $size" }
-        return RealBufferFieldOperations.multiply(a, k)
+
+        return if (a is RealBuffer) {
+            val aArray = a.array
+            RealBuffer(DoubleArray(a.size) { aArray[it] * value })
+        } else RealBuffer(DoubleArray(a.size) { a[it] * value })
     }
 
     public override fun multiply(a: Buffer<Double>, b: Buffer<Double>): RealBuffer {
diff --git a/kmath-core/src/commonTest/kotlin/space/kscience/kmath/expressions/ExpressionFieldTest.kt b/kmath-core/src/commonTest/kotlin/space/kscience/kmath/expressions/ExpressionFieldTest.kt
index c13850193..cf75eba3e 100644
--- a/kmath-core/src/commonTest/kotlin/space/kscience/kmath/expressions/ExpressionFieldTest.kt
+++ b/kmath-core/src/commonTest/kotlin/space/kscience/kmath/expressions/ExpressionFieldTest.kt
@@ -11,9 +11,7 @@ class ExpressionFieldTest {
 
     @Test
     fun testExpression() {
-        val context = FunctionalExpressionField(RealField)
-
-        val expression = context {
+        val expression = FunctionalExpressionField(RealField).invoke {
             val x by binding()
             x * x + 2 * x + one
         }
diff --git a/kmath-core/src/commonTest/kotlin/space/kscience/kmath/testutils/FieldVerifier.kt b/kmath-core/src/commonTest/kotlin/space/kscience/kmath/testutils/FieldVerifier.kt
index 2aef6b27f..cdb0a7c5d 100644
--- a/kmath-core/src/commonTest/kotlin/space/kscience/kmath/testutils/FieldVerifier.kt
+++ b/kmath-core/src/commonTest/kotlin/space/kscience/kmath/testutils/FieldVerifier.kt
@@ -5,8 +5,9 @@ import space.kscience.kmath.operations.invoke
 import kotlin.test.assertEquals
 import kotlin.test.assertNotEquals
 
-internal class FieldVerifier<T>(override val algebra: Field<T>, a: T, b: T, c: T, x: Number) :
-    RingVerifier<T>(algebra, a, b, c, x) {
+internal class FieldVerifier<T, A : Field<T>>(
+    algebra: A, a: T, b: T, c: T, x: Number,
+) : RingVerifier<T, A>(algebra, a, b, c, x) {
 
     override fun verify() {
         super.verify()
diff --git a/kmath-core/src/commonTest/kotlin/space/kscience/kmath/testutils/RingVerifier.kt b/kmath-core/src/commonTest/kotlin/space/kscience/kmath/testutils/RingVerifier.kt
index dd8841806..6970c8ac7 100644
--- a/kmath-core/src/commonTest/kotlin/space/kscience/kmath/testutils/RingVerifier.kt
+++ b/kmath-core/src/commonTest/kotlin/space/kscience/kmath/testutils/RingVerifier.kt
@@ -1,11 +1,13 @@
 package space.kscience.kmath.testutils
 
 import space.kscience.kmath.operations.Ring
+import space.kscience.kmath.operations.ScaleOperations
 import space.kscience.kmath.operations.invoke
 import kotlin.test.assertEquals
 
-internal open class RingVerifier<T>(override val algebra: Ring<T>, a: T, b: T, c: T, x: Number) :
-    SpaceVerifier<T>(algebra, a, b, c, x) {
+internal open class RingVerifier<T, A>(algebra: A, a: T, b: T, c: T, x: Number) :
+    SpaceVerifier<T, A>(algebra, a, b, c, x) where A : Ring<T>, A : ScaleOperations<T> {
+
     override fun verify() {
         super.verify()
 
diff --git a/kmath-core/src/commonTest/kotlin/space/kscience/kmath/testutils/SpaceVerifier.kt b/kmath-core/src/commonTest/kotlin/space/kscience/kmath/testutils/SpaceVerifier.kt
index f7a25b593..6ea75156b 100644
--- a/kmath-core/src/commonTest/kotlin/space/kscience/kmath/testutils/SpaceVerifier.kt
+++ b/kmath-core/src/commonTest/kotlin/space/kscience/kmath/testutils/SpaceVerifier.kt
@@ -1,18 +1,18 @@
 package space.kscience.kmath.testutils
 
+import space.kscience.kmath.operations.ScaleOperations
 import space.kscience.kmath.operations.Space
 import space.kscience.kmath.operations.invoke
 import kotlin.test.assertEquals
 import kotlin.test.assertNotEquals
 
-internal open class SpaceVerifier<T>(
-    override val algebra: Space<T>,
+internal open class SpaceVerifier<T, out S>(
+    override val algebra: S,
     val a: T,
     val b: T,
     val c: T,
-    val x: Number
-) :
-    AlgebraicVerifier<T, Space<T>> {
+    val x: Number,
+) : AlgebraicVerifier<T, Space<T>> where S : Space<T>, S : ScaleOperations<T> {
     override fun verify() {
         algebra {
             assertEquals(a + b + c, a + (b + c), "Addition in $algebra is not associative.")
diff --git a/kmath-core/src/jvmMain/kotlin/space/kscience/kmath/operations/BigNumbers.kt b/kmath-core/src/jvmMain/kotlin/space/kscience/kmath/operations/BigNumbers.kt
index 8f8b31ed9..0ac0ba1c5 100644
--- a/kmath-core/src/jvmMain/kotlin/space/kscience/kmath/operations/BigNumbers.kt
+++ b/kmath-core/src/jvmMain/kotlin/space/kscience/kmath/operations/BigNumbers.kt
@@ -7,19 +7,16 @@ import java.math.MathContext
 /**
  * A field over [BigInteger].
  */
-public object JBigIntegerField : Field<BigInteger>, NumericAlgebra<BigInteger> {
-    public override val zero: BigInteger
-        get() = BigInteger.ZERO
+public object JBigIntegerField : Ring<BigInteger>, NumericAlgebra<BigInteger> {
+    public override val zero: BigInteger get() = BigInteger.ZERO
 
-    public override val one: BigInteger
-        get() = BigInteger.ONE
+    public override val one: BigInteger get() = BigInteger.ONE
 
     public override fun number(value: Number): BigInteger = BigInteger.valueOf(value.toLong())
-    public override fun divide(a: BigInteger, b: BigInteger): BigInteger = a.div(b)
     public override fun add(a: BigInteger, b: BigInteger): BigInteger = a.add(b)
     public override operator fun BigInteger.minus(b: BigInteger): BigInteger = subtract(b)
-    public override fun multiply(a: BigInteger, k: Number): BigInteger = a.multiply(k.toInt().toBigInteger())
     public override fun multiply(a: BigInteger, b: BigInteger): BigInteger = a.multiply(b)
+
     public override operator fun BigInteger.unaryMinus(): BigInteger = negate()
 }
 
@@ -30,7 +27,7 @@ public object JBigIntegerField : Field<BigInteger>, NumericAlgebra<BigInteger> {
  */
 public abstract class JBigDecimalFieldBase internal constructor(
     private val mathContext: MathContext = MathContext.DECIMAL64,
-) : Field<BigDecimal>, PowerOperations<BigDecimal>, NumericAlgebra<BigDecimal> {
+) : Field<BigDecimal>, PowerOperations<BigDecimal>, NumericAlgebra<BigDecimal>, ScaleOperations<BigDecimal> {
     public override val zero: BigDecimal
         get() = BigDecimal.ZERO
 
@@ -41,8 +38,8 @@ public abstract class JBigDecimalFieldBase internal constructor(
     public override operator fun BigDecimal.minus(b: BigDecimal): BigDecimal = subtract(b)
     public override fun number(value: Number): BigDecimal = BigDecimal.valueOf(value.toDouble())
 
-    public override fun multiply(a: BigDecimal, k: Number): BigDecimal =
-        a.multiply(k.toDouble().toBigDecimal(mathContext), mathContext)
+    public override fun scale(a: BigDecimal, value: Double): BigDecimal =
+        a.multiply(value.toBigDecimal(mathContext), mathContext)
 
     public override fun multiply(a: BigDecimal, b: BigDecimal): BigDecimal = a.multiply(b, mathContext)
     public override fun divide(a: BigDecimal, b: BigDecimal): BigDecimal = a.divide(b, mathContext)
diff --git a/kmath-coroutines/src/commonMain/kotlin/space/kscience/kmath/chains/flowExtra.kt b/kmath-coroutines/src/commonMain/kotlin/space/kscience/kmath/chains/flowExtra.kt
index 489cca8c1..eff813bee 100644
--- a/kmath-coroutines/src/commonMain/kotlin/space/kscience/kmath/chains/flowExtra.kt
+++ b/kmath-coroutines/src/commonMain/kotlin/space/kscience/kmath/chains/flowExtra.kt
@@ -5,16 +5,16 @@ import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.runningReduce
 import kotlinx.coroutines.flow.scan
+import space.kscience.kmath.operations.ScaleOperations
 import space.kscience.kmath.operations.Space
 import space.kscience.kmath.operations.SpaceOperations
 import space.kscience.kmath.operations.invoke
 
-@ExperimentalCoroutinesApi
 public fun <T> Flow<T>.cumulativeSum(space: SpaceOperations<T>): Flow<T> =
     space { runningReduce { sum, element -> sum + element } }
 
 @ExperimentalCoroutinesApi
-public fun <T> Flow<T>.mean(space: Space<T>): Flow<T> = space {
+public fun <T, S> Flow<T>.mean(algebra: S): Flow<T> where S : Space<T>, S : ScaleOperations<T> = algebra {
     data class Accumulator(var sum: T, var num: Int)
 
     scan(Accumulator(zero, 0)) { sum, element ->
diff --git a/kmath-ejml/src/main/kotlin/space/kscience/kmath/ejml/EjmlMatrixContext.kt b/kmath-ejml/src/main/kotlin/space/kscience/kmath/ejml/EjmlMatrixContext.kt
index d67f80409..95c465975 100644
--- a/kmath-ejml/src/main/kotlin/space/kscience/kmath/ejml/EjmlMatrixContext.kt
+++ b/kmath-ejml/src/main/kotlin/space/kscience/kmath/ejml/EjmlMatrixContext.kt
@@ -4,13 +4,14 @@ import org.ejml.simple.SimpleMatrix
 import space.kscience.kmath.linear.*
 import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.nd.getFeature
+import space.kscience.kmath.operations.ScaleOperations
 
 /**
  * Represents context of basic operations operating with [EjmlMatrix].
  *
  * @author Iaroslav Postovalov
  */
-public object EjmlMatrixContext : MatrixContext<Double, EjmlMatrix> {
+public object EjmlMatrixContext : MatrixContext<Double, EjmlMatrix>, ScaleOperations<Matrix<Double>> {
 
     /**
      * Converts this matrix to EJML one.
@@ -41,6 +42,9 @@ public object EjmlMatrixContext : MatrixContext<Double, EjmlMatrix> {
             (0 until it.numRows()).forEach { row -> it[row, 0] = initializer(row) }
         })
 
+
+    override fun Matrix<Double>.unaryMinus(): Matrix<Double>  = this*(-1)
+
     public override fun Matrix<Double>.dot(other: Matrix<Double>): EjmlMatrix =
         EjmlMatrix(toEjml().origin.mult(other.toEjml().origin))
 
@@ -53,8 +57,8 @@ public object EjmlMatrixContext : MatrixContext<Double, EjmlMatrix> {
     public override operator fun Matrix<Double>.minus(b: Matrix<Double>): EjmlMatrix =
         EjmlMatrix(toEjml().origin - b.toEjml().origin)
 
-    public override fun multiply(a: Matrix<Double>, k: Number): EjmlMatrix =
-        produce(a.rowNum, a.colNum) { i, j -> a[i, j] * k.toDouble() }
+    public override fun scale(a: Matrix<Double>, value: Double): EjmlMatrix =
+        produce(a.rowNum, a.colNum) { i, j -> a[i, j] * value }
 
     public override operator fun Matrix<Double>.times(value: Double): EjmlMatrix =
         EjmlMatrix(toEjml().origin.scale(value))
diff --git a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/Polynomial.kt b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/Polynomial.kt
index b1e47f34c..7416069bd 100644
--- a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/Polynomial.kt
+++ b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/Polynomial.kt
@@ -1,6 +1,7 @@
 package space.kscience.kmath.functions
 
 import space.kscience.kmath.operations.Ring
+import space.kscience.kmath.operations.ScaleOperations
 import space.kscience.kmath.operations.Space
 import space.kscience.kmath.operations.invoke
 import kotlin.contracts.InvocationKind
@@ -41,9 +42,15 @@ public fun <T : Any, C : Ring<T>> Polynomial<T>.asFunction(ring: C): (T) -> T =
 /**
  * An algebra for polynomials
  */
-public class PolynomialSpace<T : Any, C : Ring<T>>(private val ring: C) : Space<Polynomial<T>> {
+public class PolynomialSpace<T : Any, C >(
+    private val ring: C,
+) : Space<Polynomial<T>>, ScaleOperations<Polynomial<T>> where C: Ring<T>, C: ScaleOperations<T>{
     public override val zero: Polynomial<T> = Polynomial(emptyList())
 
+    override fun Polynomial<T>.unaryMinus(): Polynomial<T> = with(ring) {
+        Polynomial(coefficients.map { -it })
+    }
+
     public override fun add(a: Polynomial<T>, b: Polynomial<T>): Polynomial<T> {
         val dim = max(a.coefficients.size, b.coefficients.size)
 
@@ -54,13 +61,13 @@ public class PolynomialSpace<T : Any, C : Ring<T>>(private val ring: C) : Space<
         }
     }
 
-    public override fun multiply(a: Polynomial<T>, k: Number): Polynomial<T> =
-        ring { Polynomial(List(a.coefficients.size) { index -> a.coefficients[index] * k }) }
+    public override fun scale(a: Polynomial<T>, value: Double): Polynomial<T> =
+        ring { Polynomial(List(a.coefficients.size) { index -> a.coefficients[index] * value }) }
 
     public operator fun Polynomial<T>.invoke(arg: T): T = value(ring, arg)
 }
 
-public inline fun <T : Any, C : Ring<T>, R> C.polynomial(block: PolynomialSpace<T, C>.() -> R): R {
+public inline fun <T : Any, C, R> C.polynomial(block: PolynomialSpace<T, C>.() -> R): R where C: Ring<T>, C: ScaleOperations<T>{
     contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) }
     return PolynomialSpace(this).block()
 }
diff --git a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/interpolation/SplineInterpolator.kt b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/interpolation/SplineInterpolator.kt
index 34fd25ad4..78d6e0d0c 100644
--- a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/interpolation/SplineInterpolator.kt
+++ b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/interpolation/SplineInterpolator.kt
@@ -11,9 +11,9 @@ import space.kscience.kmath.structures.MutableBufferFactory
  * Generic spline interpolator. Not recommended for performance critical places, use platform-specific and type specific ones.
  * Based on https://github.com/apache/commons-math/blob/eb57d6d457002a0bb5336d789a3381a24599affe/src/main/java/org/apache/commons/math4/analysis/interpolation/SplineInterpolator.java
  */
-public class SplineInterpolator<T : Comparable<T>>(
-    public override val algebra: Field<T>,
-    public val bufferFactory: MutableBufferFactory<T>
+public class SplineInterpolator<T : Comparable<T>, F : Field<T>>(
+    public override val algebra: F,
+    public val bufferFactory: MutableBufferFactory<T>,
 ) : PolynomialInterpolator<T> {
     //TODO possibly optimize zeroed buffers
 
diff --git a/kmath-geometry/src/commonMain/kotlin/space/kscience/kmath/geometry/Euclidean2DSpace.kt b/kmath-geometry/src/commonMain/kotlin/space/kscience/kmath/geometry/Euclidean2DSpace.kt
index 609274d7d..54a1e032c 100644
--- a/kmath-geometry/src/commonMain/kotlin/space/kscience/kmath/geometry/Euclidean2DSpace.kt
+++ b/kmath-geometry/src/commonMain/kotlin/space/kscience/kmath/geometry/Euclidean2DSpace.kt
@@ -2,6 +2,7 @@ package space.kscience.kmath.geometry
 
 import space.kscience.kmath.linear.Point
 import space.kscience.kmath.misc.UnstableKMathAPI
+import space.kscience.kmath.operations.ScaleOperations
 import space.kscience.kmath.operations.SpaceElement
 import space.kscience.kmath.operations.invoke
 import kotlin.math.sqrt
@@ -30,18 +31,20 @@ public fun Vector2D(x: Double, y: Double): Vector2D = Vector2DImpl(x, y)
 
 private data class Vector2DImpl(
     override val x: Double,
-    override val y: Double
+    override val y: Double,
 ) : Vector2D
 
 /**
  * 2D Euclidean space
  */
-public object Euclidean2DSpace : GeometrySpace<Vector2D> {
+public object Euclidean2DSpace : GeometrySpace<Vector2D>, ScaleOperations<Vector2D> {
     public override val zero: Vector2D by lazy { Vector2D(0.0, 0.0) }
 
     public fun Vector2D.norm(): Double = sqrt(x * x + y * y)
+    override fun Vector2D.unaryMinus(): Vector2D = Vector2D(-x, -y)
+
     public override fun Vector2D.distanceTo(other: Vector2D): Double = (this - other).norm()
     public override fun add(a: Vector2D, b: Vector2D): Vector2D = Vector2D(a.x + b.x, a.y + b.y)
-    public override fun multiply(a: Vector2D, k: Number): Vector2D = Vector2D(a.x * k.toDouble(), a.y * k.toDouble())
+    public override fun scale(a: Vector2D, value: Double): Vector2D = Vector2D(a.x * value, a.y * value)
     public override fun Vector2D.dot(other: Vector2D): Double = x * other.x + y * other.y
 }
diff --git a/kmath-geometry/src/commonMain/kotlin/space/kscience/kmath/geometry/Euclidean3DSpace.kt b/kmath-geometry/src/commonMain/kotlin/space/kscience/kmath/geometry/Euclidean3DSpace.kt
index 906f5df03..ed110e383 100644
--- a/kmath-geometry/src/commonMain/kotlin/space/kscience/kmath/geometry/Euclidean3DSpace.kt
+++ b/kmath-geometry/src/commonMain/kotlin/space/kscience/kmath/geometry/Euclidean3DSpace.kt
@@ -2,6 +2,7 @@ package space.kscience.kmath.geometry
 
 import space.kscience.kmath.linear.Point
 import space.kscience.kmath.misc.UnstableKMathAPI
+import space.kscience.kmath.operations.ScaleOperations
 import space.kscience.kmath.operations.SpaceElement
 import space.kscience.kmath.operations.invoke
 import kotlin.math.sqrt
@@ -32,21 +33,22 @@ public val Vector3D.r: Double get() = Euclidean3DSpace { sqrt(norm()) }
 private data class Vector3DImpl(
     override val x: Double,
     override val y: Double,
-    override val z: Double
+    override val z: Double,
 ) : Vector3D
 
-public object Euclidean3DSpace : GeometrySpace<Vector3D> {
+public object Euclidean3DSpace : GeometrySpace<Vector3D>, ScaleOperations<Vector3D> {
     public override val zero: Vector3D by lazy { Vector3D(0.0, 0.0, 0.0) }
 
     public fun Vector3D.norm(): Double = sqrt(x * x + y * y + z * z)
+    override fun Vector3D.unaryMinus(): Vector3D = Vector3D(-x, -y, -z)
 
     public override fun Vector3D.distanceTo(other: Vector3D): Double = (this - other).norm()
 
     public override fun add(a: Vector3D, b: Vector3D): Vector3D =
         Vector3D(a.x + b.x, a.y + b.y, a.z + b.z)
 
-    public override fun multiply(a: Vector3D, k: Number): Vector3D =
-        Vector3D(a.x * k.toDouble(), a.y * k.toDouble(), a.z * k.toDouble())
+    public override fun scale(a: Vector3D, value: Double): Vector3D =
+        Vector3D(a.x * value, a.y * value, a.z * value)
 
     public override fun Vector3D.dot(other: Vector3D): Double =
         x * other.x + y * other.y + z * other.z
diff --git a/kmath-histograms/src/commonMain/kotlin/space/kscience/kmath/histogram/IndexedHistogramSpace.kt b/kmath-histograms/src/commonMain/kotlin/space/kscience/kmath/histogram/IndexedHistogramSpace.kt
index 85262abeb..b82644481 100644
--- a/kmath-histograms/src/commonMain/kotlin/space/kscience/kmath/histogram/IndexedHistogramSpace.kt
+++ b/kmath-histograms/src/commonMain/kotlin/space/kscience/kmath/histogram/IndexedHistogramSpace.kt
@@ -3,9 +3,10 @@ package space.kscience.kmath.histogram
 import space.kscience.kmath.domains.Domain
 import space.kscience.kmath.linear.Point
 import space.kscience.kmath.misc.UnstableKMathAPI
-import space.kscience.kmath.nd.NDSpace
+import space.kscience.kmath.nd.NDField
 import space.kscience.kmath.nd.NDStructure
 import space.kscience.kmath.nd.Strides
+import space.kscience.kmath.operations.ScaleOperations
 import space.kscience.kmath.operations.Space
 import space.kscience.kmath.operations.SpaceElement
 import space.kscience.kmath.operations.invoke
@@ -41,10 +42,11 @@ public class IndexedHistogram<T : Comparable<T>, V : Any>(
 /**
  * A space for producing histograms with values in a NDStructure
  */
-public interface IndexedHistogramSpace<T : Comparable<T>, V : Any> : Space<IndexedHistogram<T, V>> {
+public interface IndexedHistogramSpace<T : Comparable<T>, V : Any>
+    : Space<IndexedHistogram<T, V>>, ScaleOperations<IndexedHistogram<T, V>> {
     //public val valueSpace: Space<V>
     public val strides: Strides
-    public val histogramValueSpace: NDSpace<V, *> //= NDAlgebra.space(valueSpace, Buffer.Companion::boxing, *shape),
+    public val histogramValueSpace: NDField<V, *> //= NDAlgebra.space(valueSpace, Buffer.Companion::boxing, *shape),
 
     /**
      * Resolve index of the bin including given [point]
@@ -63,12 +65,12 @@ public interface IndexedHistogramSpace<T : Comparable<T>, V : Any> : Space<Index
     override fun add(a: IndexedHistogram<T, V>, b: IndexedHistogram<T, V>): IndexedHistogram<T, V> {
         require(a.context == this) { "Can't operate on a histogram produced by external space" }
         require(b.context == this) { "Can't operate on a histogram produced by external space" }
-        return IndexedHistogram(this, histogramValueSpace.invoke { a.values + b.values })
+        return IndexedHistogram(this, histogramValueSpace { a.values + b.values })
     }
 
-    override fun multiply(a: IndexedHistogram<T, V>, k: Number): IndexedHistogram<T, V> {
+    override fun scale(a: IndexedHistogram<T, V>, value: Double): IndexedHistogram<T, V> {
         require(a.context == this) { "Can't operate on a histogram produced by external space" }
-        return IndexedHistogram(this, histogramValueSpace.invoke { a.values * k })
+        return IndexedHistogram(this, histogramValueSpace { a.values * value })
     }
 
     override val zero: IndexedHistogram<T, V> get() = produce { }
diff --git a/kmath-histograms/src/commonMain/kotlin/space/kscience/kmath/histogram/RealHistogramSpace.kt b/kmath-histograms/src/commonMain/kotlin/space/kscience/kmath/histogram/RealHistogramSpace.kt
index 26efdf1fe..3df0b1626 100644
--- a/kmath-histograms/src/commonMain/kotlin/space/kscience/kmath/histogram/RealHistogramSpace.kt
+++ b/kmath-histograms/src/commonMain/kotlin/space/kscience/kmath/histogram/RealHistogramSpace.kt
@@ -2,6 +2,7 @@ package space.kscience.kmath.histogram
 
 import space.kscience.kmath.domains.Domain
 import space.kscience.kmath.domains.HyperSquareDomain
+import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.nd.*
 import space.kscience.kmath.structures.*
 import kotlin.math.floor
@@ -40,6 +41,7 @@ public class RealHistogramSpace(
         getIndex(it, point[it])
     }
 
+    @OptIn(UnstableKMathAPI::class)
     override fun getDomain(index: IntArray): Domain<Double> {
         val lowerBoundary = index.mapIndexed { axis, i ->
             when (i) {
@@ -77,6 +79,8 @@ public class RealHistogramSpace(
         return IndexedHistogram(this, values)
     }
 
+    override fun IndexedHistogram<Double, Double>.unaryMinus(): IndexedHistogram<Double, Double> = this * (-1)
+
     public companion object {
         /**
          * Use it like
diff --git a/kmath-histograms/src/jvmMain/kotlin/space/kscience/kmath/histogram/TreeHistogramSpace.kt b/kmath-histograms/src/jvmMain/kotlin/space/kscience/kmath/histogram/TreeHistogramSpace.kt
index ddecc4332..85e82f515 100644
--- a/kmath-histograms/src/jvmMain/kotlin/space/kscience/kmath/histogram/TreeHistogramSpace.kt
+++ b/kmath-histograms/src/jvmMain/kotlin/space/kscience/kmath/histogram/TreeHistogramSpace.kt
@@ -2,6 +2,7 @@ package space.kscience.kmath.histogram
 
 import space.kscience.kmath.domains.UnivariateDomain
 import space.kscience.kmath.misc.UnstableKMathAPI
+import space.kscience.kmath.operations.ScaleOperations
 import space.kscience.kmath.operations.Space
 import space.kscience.kmath.structures.Buffer
 import java.util.*
@@ -36,7 +37,7 @@ public class TreeHistogram(
 @UnstableKMathAPI
 public class TreeHistogramSpace(
     public val binFactory: (Double) -> UnivariateDomain,
-) : Space<UnivariateHistogram> {
+) : Space<UnivariateHistogram>, ScaleOperations<UnivariateHistogram> {
 
     private class BinCounter(val domain: UnivariateDomain, val counter: Counter<Double> = Counter.real()) :
         ClosedFloatingPointRange<Double> by domain.range
@@ -97,14 +98,14 @@ public class TreeHistogramSpace(
         return TreeHistogram(this, bins)
     }
 
-    override fun multiply(a: UnivariateHistogram, k: Number): UnivariateHistogram {
+    override fun scale(a: UnivariateHistogram, value: Double): UnivariateHistogram {
         val bins = TreeMap<Double, UnivariateBin>().apply {
             a.bins.forEach { bin ->
                 put(bin.domain.center,
                     UnivariateBin(
                         bin.domain,
-                        value = bin.value * k.toDouble(),
-                        standardDeviation = abs(bin.standardDeviation * k.toDouble())
+                        value = bin.value * value.toDouble(),
+                        standardDeviation = abs(bin.standardDeviation * value.toDouble())
                     )
                 )
             }
@@ -113,6 +114,8 @@ public class TreeHistogramSpace(
         return TreeHistogram(this, bins)
     }
 
+    override fun UnivariateHistogram.unaryMinus(): UnivariateHistogram = this * (-1)
+
     override val zero: UnivariateHistogram = produce { }
 
     public companion object {
diff --git a/kmath-histograms/src/jvmMain/kotlin/space/kscience/kmath/histogram/UnivariateHistogram.kt b/kmath-histograms/src/jvmMain/kotlin/space/kscience/kmath/histogram/UnivariateHistogram.kt
index 8c4f9e434..96e3d41ae 100644
--- a/kmath-histograms/src/jvmMain/kotlin/space/kscience/kmath/histogram/UnivariateHistogram.kt
+++ b/kmath-histograms/src/jvmMain/kotlin/space/kscience/kmath/histogram/UnivariateHistogram.kt
@@ -8,6 +8,7 @@ import space.kscience.kmath.structures.Buffer
 import space.kscience.kmath.structures.asSequence
 
 
+@UnstableKMathAPI
 public val UnivariateDomain.center: Double get() = (range.endInclusive - range.start) / 2
 
 /**
@@ -15,6 +16,7 @@ public val UnivariateDomain.center: Double get() = (range.endInclusive - range.s
  * @param value The value of histogram including weighting
  * @param standardDeviation Standard deviation of the bin value. Zero or negative if not applicable
  */
+@UnstableKMathAPI
 public class UnivariateBin(
     public val domain: UnivariateDomain,
     override val value: Double,
diff --git a/kmath-nd4j/src/main/kotlin/space/kscience/kmath/nd4j/Nd4jArrayAlgebra.kt b/kmath-nd4j/src/main/kotlin/space/kscience/kmath/nd4j/Nd4jArrayAlgebra.kt
index c50174b95..11e7b73e4 100644
--- a/kmath-nd4j/src/main/kotlin/space/kscience/kmath/nd4j/Nd4jArrayAlgebra.kt
+++ b/kmath-nd4j/src/main/kotlin/space/kscience/kmath/nd4j/Nd4jArrayAlgebra.kt
@@ -20,7 +20,7 @@ internal fun NDAlgebra<*, *>.checkShape(array: INDArray): INDArray {
  * @param T the type of ND-structure element.
  * @param C the type of the element context.
  */
-public interface Nd4jArrayAlgebra<T, C> : NDAlgebra<T, C> {
+public interface Nd4jArrayAlgebra<T, C : Algebra<T>> : NDAlgebra<T, C> {
     /**
      * Wraps [INDArray] to [N].
      */
@@ -92,18 +92,9 @@ public interface Nd4jArraySpace<T, S : Space<T>> : NDSpace<T, S>, Nd4jArrayAlgeb
         return ndArray.neg().wrap()
     }
 
-    public override fun multiply(a: NDStructure<T>, k: Number): Nd4jArrayStructure<T> {
+    public fun multiply(a: NDStructure<T>, k: Number): Nd4jArrayStructure<T> {
         return a.ndArray.mul(k).wrap()
     }
-
-    @Deprecated("Avoid using this method, underlying array get casted to Doubles")
-    public override operator fun NDStructure<T>.div(k: Number): Nd4jArrayStructure<T> {
-        return ndArray.div(k).wrap()
-    }
-
-    public override operator fun NDStructure<T>.times(k: Number): Nd4jArrayStructure<T> {
-        return ndArray.mul(k).wrap()
-    }
 }
 
 /**
@@ -180,8 +171,7 @@ public interface Nd4jArrayField<T, F : Field<T>> : NDField<T, F>, Nd4jArrayRing<
     public override fun divide(a: NDStructure<T>, b: NDStructure<T>): Nd4jArrayStructure<T> =
         a.ndArray.div(b.ndArray).wrap()
 
-    public override operator fun Number.div(b: NDStructure<T>): Nd4jArrayStructure<T> = b.ndArray.rdiv(this).wrap()
-
+    public operator fun Number.div(b: NDStructure<T>): Nd4jArrayStructure<T> = b.ndArray.rdiv(this).wrap()
 
     public companion object {
         private val floatNd4jArrayFieldCache: ThreadLocal<MutableMap<IntArray, FloatNd4jArrayField>> =
@@ -218,11 +208,14 @@ public interface Nd4jArrayField<T, F : Field<T>> : NDField<T, F>, Nd4jArrayRing<
  * Represents [NDField] over [Nd4jArrayRealStructure].
  */
 public class RealNd4jArrayField(public override val shape: IntArray) : Nd4jArrayField<Double, RealField> {
-    public override val elementContext: RealField
-        get() = RealField
+    public override val elementContext: RealField get() = RealField
 
     public override fun INDArray.wrap(): Nd4jArrayStructure<Double> = checkShape(this).asRealStructure()
 
+    override fun scale(a: NDStructure<Double>, value: Double): Nd4jArrayStructure<Double> {
+        return a.ndArray.mul(value).wrap()
+    }
+
     public override operator fun NDStructure<Double>.div(arg: Double): Nd4jArrayStructure<Double> {
         return ndArray.div(arg).wrap()
     }
@@ -257,6 +250,10 @@ public class FloatNd4jArrayField(public override val shape: IntArray) : Nd4jArra
 
     public override fun INDArray.wrap(): Nd4jArrayStructure<Float> = checkShape(this).asFloatStructure()
 
+    override fun scale(a: NDStructure<Float>, value: Double): NDStructure<Float> {
+        return a.ndArray.mul(value).wrap()
+    }
+
     public override operator fun NDStructure<Float>.div(arg: Float): Nd4jArrayStructure<Float> {
         return ndArray.div(arg).wrap()
     }
diff --git a/kmath-stat/src/commonMain/kotlin/space/kscience/kmath/stat/SamplerAlgebra.kt b/kmath-stat/src/commonMain/kotlin/space/kscience/kmath/stat/SamplerAlgebra.kt
index 9fed91e1f..ca2fd58cc 100644
--- a/kmath-stat/src/commonMain/kotlin/space/kscience/kmath/stat/SamplerAlgebra.kt
+++ b/kmath-stat/src/commonMain/kotlin/space/kscience/kmath/stat/SamplerAlgebra.kt
@@ -4,6 +4,7 @@ import space.kscience.kmath.chains.Chain
 import space.kscience.kmath.chains.ConstantChain
 import space.kscience.kmath.chains.map
 import space.kscience.kmath.chains.zip
+import space.kscience.kmath.operations.ScaleOperations
 import space.kscience.kmath.operations.Space
 import space.kscience.kmath.operations.invoke
 
@@ -18,14 +19,18 @@ public class ConstantSampler<T : Any>(public val value: T) : Sampler<T> {
 /**
  * A space for samplers. Allows to perform simple operations on distributions
  */
-public class SamplerSpace<T : Any>(public val space: Space<T>) : Space<Sampler<T>> {
-    public override val zero: Sampler<T> = ConstantSampler(space.zero)
+public class SamplerSpace<T : Any, S>(public val algebra: S) : Space<Sampler<T>>,
+    ScaleOperations<Sampler<T>> where S : Space<T>, S : ScaleOperations<T> {
+
+    public override val zero: Sampler<T> = ConstantSampler(algebra.zero)
 
     public override fun add(a: Sampler<T>, b: Sampler<T>): Sampler<T> = BasicSampler { generator ->
-        a.sample(generator).zip(b.sample(generator)) { aValue, bValue -> space { aValue + bValue } }
+        a.sample(generator).zip(b.sample(generator)) { aValue, bValue -> algebra { aValue + bValue } }
     }
 
-    public override fun multiply(a: Sampler<T>, k: Number): Sampler<T> = BasicSampler { generator ->
-        a.sample(generator).map { space { it * k.toDouble() } }
+    public override fun scale(a: Sampler<T>, value: Double): Sampler<T> = BasicSampler { generator ->
+        a.sample(generator).map { algebra { it * value } }
     }
+
+    override fun Sampler<T>.unaryMinus(): Sampler<T> = scale(this, -1.0)
 }
diff --git a/kmath-stat/src/commonMain/kotlin/space/kscience/kmath/stat/Statistic.kt b/kmath-stat/src/commonMain/kotlin/space/kscience/kmath/stat/Statistic.kt
index 29ded2b88..4a3103d1b 100644
--- a/kmath-stat/src/commonMain/kotlin/space/kscience/kmath/stat/Statistic.kt
+++ b/kmath-stat/src/commonMain/kotlin/space/kscience/kmath/stat/Statistic.kt
@@ -43,7 +43,7 @@ public interface ComposableStatistic<T, I, R> : Statistic<T, R> {
 @ExperimentalCoroutinesApi
 private fun <T, I, R> ComposableStatistic<T, I, R>.flowIntermediate(
     flow: Flow<Buffer<T>>,
-    dispatcher: CoroutineDispatcher = Dispatchers.Default
+    dispatcher: CoroutineDispatcher = Dispatchers.Default,
 ): Flow<I> = flow
     .mapParallel(dispatcher) { computeIntermediate(it) }
     .runningReduce(::composeIntermediate)
@@ -59,27 +59,31 @@ private fun <T, I, R> ComposableStatistic<T, I, R>.flowIntermediate(
 @ExperimentalCoroutinesApi
 public fun <T, I, R> ComposableStatistic<T, I, R>.flow(
     flow: Flow<Buffer<T>>,
-    dispatcher: CoroutineDispatcher = Dispatchers.Default
+    dispatcher: CoroutineDispatcher = Dispatchers.Default,
 ): Flow<R> = flowIntermediate(flow, dispatcher).map(::toResult)
 
 /**
  * Arithmetic mean
  */
-public class Mean<T>(public val space: Space<T>) : ComposableStatistic<T, Pair<T, Int>, T> {
+public class Mean<T>(
+    private val space: Space<T>,
+    private val division: (sum: T, count: Int) -> T,
+) : ComposableStatistic<T, Pair<T, Int>, T> {
     public override suspend fun computeIntermediate(data: Buffer<T>): Pair<T, Int> =
         space { sum(data.asIterable()) } to data.size
 
     public override suspend fun composeIntermediate(first: Pair<T, Int>, second: Pair<T, Int>): Pair<T, Int> =
         space { first.first + second.first } to (first.second + second.second)
 
-    public override suspend fun toResult(intermediate: Pair<T, Int>): T =
-        space { intermediate.first / intermediate.second }
+    public override suspend fun toResult(intermediate: Pair<T, Int>): T = space {
+        division(intermediate.first, intermediate.second)
+    }
 
     public companion object {
         //TODO replace with optimized version which respects overflow
-        public val real: Mean<Double> = Mean(RealField)
-        public val int: Mean<Int> = Mean(IntRing)
-        public val long: Mean<Long> = Mean(LongRing)
+        public val real: Mean<Double> = Mean(RealField) { sum, count -> sum / count }
+        public val int: Mean<Int> = Mean(IntRing) { sum, count -> sum / count }
+        public val long: Mean<Long> = Mean(LongRing) { sum, count -> sum / count }
     }
 }
 
diff --git a/kmath-viktor/api/kmath-viktor.api b/kmath-viktor/api/kmath-viktor.api
index 462e065bf..ebb97b150 100644
--- a/kmath-viktor/api/kmath-viktor.api
+++ b/kmath-viktor/api/kmath-viktor.api
@@ -26,7 +26,7 @@ public final class space/kscience/kmath/viktor/ViktorBuffer : space/kscience/kma
 	public final synthetic fun unbox-impl ()Lorg/jetbrains/bio/viktor/F64FlatArray;
 }
 
-public final class space/kscience/kmath/viktor/ViktorNDField : space/kscience/kmath/nd/NDField, space/kscience/kmath/operations/ExtendedField, space/kscience/kmath/operations/RingWithNumbers {
+public final class space/kscience/kmath/viktor/ViktorNDField : space/kscience/kmath/nd/NDField, space/kscience/kmath/operations/ExtendedField, space/kscience/kmath/operations/NumbersAddOperations, space/kscience/kmath/operations/ScaleOperations {
 	public fun <init> ([I)V
 	public synthetic fun acos (Ljava/lang/Object;)Ljava/lang/Object;
 	public fun acos-Q7Xurp0 (Lspace/kscience/kmath/nd/NDStructure;)Lorg/jetbrains/bio/viktor/F64Array;
@@ -55,8 +55,6 @@ public final class space/kscience/kmath/viktor/ViktorNDField : space/kscience/km
 	public synthetic fun cosh (Ljava/lang/Object;)Ljava/lang/Object;
 	public fun cosh (Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 	public fun div (DLspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
-	public synthetic fun div (Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun div (Ljava/lang/Number;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 	public synthetic fun div (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public synthetic fun div (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public synthetic fun div (Ljava/lang/Object;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
@@ -68,7 +66,7 @@ public final class space/kscience/kmath/viktor/ViktorNDField : space/kscience/km
 	public fun divide (Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 	public synthetic fun exp (Ljava/lang/Object;)Ljava/lang/Object;
 	public fun exp-Q7Xurp0 (Lspace/kscience/kmath/nd/NDStructure;)Lorg/jetbrains/bio/viktor/F64Array;
-	public synthetic fun getElementContext ()Ljava/lang/Object;
+	public synthetic fun getElementContext ()Lspace/kscience/kmath/operations/Algebra;
 	public fun getElementContext ()Lspace/kscience/kmath/operations/RealField;
 	public final fun getF64Buffer (Lspace/kscience/kmath/nd/NDStructure;)Lorg/jetbrains/bio/viktor/F64Array;
 	public synthetic fun getOne ()Ljava/lang/Object;
@@ -96,11 +94,8 @@ public final class space/kscience/kmath/viktor/ViktorNDField : space/kscience/km
 	public fun minus (Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Number;)Lspace/kscience/kmath/nd/NDStructure;
 	public synthetic fun minus (Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Object;)Lspace/kscience/kmath/nd/NDStructure;
 	public fun minus-s8yP2C4 (Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;)Lorg/jetbrains/bio/viktor/F64Array;
-	public synthetic fun multiply (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public synthetic fun multiply (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public synthetic fun multiply (Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Number;)Lspace/kscience/kmath/nd/NDStructure;
 	public fun multiply (Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
-	public fun multiply-s8yP2C4 (Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Number;)Lorg/jetbrains/bio/viktor/F64Array;
 	public synthetic fun number (Ljava/lang/Number;)Ljava/lang/Object;
 	public fun number-Q7Xurp0 (Ljava/lang/Number;)Lorg/jetbrains/bio/viktor/F64Array;
 	public fun plus (DLspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
@@ -122,6 +117,8 @@ public final class space/kscience/kmath/viktor/ViktorNDField : space/kscience/km
 	public synthetic fun rightSideNumberOperation (Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public fun rightSideNumberOperation (Ljava/lang/String;Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Number;)Lspace/kscience/kmath/nd/NDStructure;
 	public fun rightSideNumberOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
+	public synthetic fun scale (Ljava/lang/Object;D)Ljava/lang/Object;
+	public fun scale-s8yP2C4 (Lspace/kscience/kmath/nd/NDStructure;D)Lorg/jetbrains/bio/viktor/F64Array;
 	public synthetic fun sin (Ljava/lang/Object;)Ljava/lang/Object;
 	public fun sin-Q7Xurp0 (Lspace/kscience/kmath/nd/NDStructure;)Lorg/jetbrains/bio/viktor/F64Array;
 	public synthetic fun sinh (Ljava/lang/Object;)Ljava/lang/Object;
diff --git a/kmath-viktor/src/main/kotlin/space/kscience/kmath/viktor/ViktorNDStructure.kt b/kmath-viktor/src/main/kotlin/space/kscience/kmath/viktor/ViktorNDStructure.kt
index 8deda2544..218afcbef 100644
--- a/kmath-viktor/src/main/kotlin/space/kscience/kmath/viktor/ViktorNDStructure.kt
+++ b/kmath-viktor/src/main/kotlin/space/kscience/kmath/viktor/ViktorNDStructure.kt
@@ -4,8 +4,9 @@ import org.jetbrains.bio.viktor.F64Array
 import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.nd.*
 import space.kscience.kmath.operations.ExtendedField
+import space.kscience.kmath.operations.NumbersAddOperations
 import space.kscience.kmath.operations.RealField
-import space.kscience.kmath.operations.RingWithNumbers
+import space.kscience.kmath.operations.ScaleOperations
 
 @Suppress("OVERRIDE_BY_INLINE", "NOTHING_TO_INLINE")
 public inline class ViktorNDStructure(public val f64Buffer: F64Array) : MutableNDStructure<Double> {
@@ -26,7 +27,8 @@ public fun F64Array.asStructure(): ViktorNDStructure = ViktorNDStructure(this)
 @OptIn(UnstableKMathAPI::class)
 @Suppress("OVERRIDE_BY_INLINE", "NOTHING_TO_INLINE")
 public class ViktorNDField(public override val shape: IntArray) : NDField<Double, RealField>,
-    RingWithNumbers<NDStructure<Double>>, ExtendedField<NDStructure<Double>> {
+    NumbersAddOperations<NDStructure<Double>>, ExtendedField<NDStructure<Double>>,
+    ScaleOperations<NDStructure<Double>> {
 
     public val NDStructure<Double>.f64Buffer: F64Array
         get() = when {
@@ -55,6 +57,8 @@ public class ViktorNDField(public override val shape: IntArray) : NDField<Double
             }
         }.asStructure()
 
+    override fun NDStructure<Double>.unaryMinus(): NDStructure<Double> = this * (-1)
+
     public override fun NDStructure<Double>.map(transform: RealField.(Double) -> Double): ViktorNDStructure =
         F64Array(*this@ViktorNDField.shape).apply {
             this@ViktorNDField.strides.indices().forEach { index ->
@@ -83,8 +87,8 @@ public class ViktorNDField(public override val shape: IntArray) : NDField<Double
     public override fun add(a: NDStructure<Double>, b: NDStructure<Double>): ViktorNDStructure =
         (a.f64Buffer + b.f64Buffer).asStructure()
 
-    public override fun multiply(a: NDStructure<Double>, k: Number): ViktorNDStructure =
-        (a.f64Buffer * k.toDouble()).asStructure()
+    public override fun scale(a: NDStructure<Double>, value: Double): ViktorNDStructure =
+        (a.f64Buffer * value.toDouble()).asStructure()
 
     public override inline fun NDStructure<Double>.plus(b: NDStructure<Double>): ViktorNDStructure =
         (f64Buffer + b.f64Buffer).asStructure()
diff --git a/settings.gradle.kts b/settings.gradle.kts
index cadbfd7ba..b4d7b3049 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -1,14 +1,15 @@
 pluginManagement {
     repositories {
+        maven("https://repo.kotlin.link")
+        mavenLocal()
         gradlePluginPortal()
         jcenter()
-        maven("https://repo.kotlin.link")
         maven("https://dl.bintray.com/kotlin/kotlin-eap")
         maven("https://dl.bintray.com/kotlin/kotlinx")
     }
 
-    val toolsVersion = "0.8.1"
-    val kotlinVersion = "1.4.30"
+    val toolsVersion = "0.9.1"
+    val kotlinVersion = "1.4.31"
 
     plugins {
         id("kotlinx.benchmark") version "0.2.0-dev-20"
-- 
2.34.1


From 940718098dd588860e33aefde1d027a80dfdf61b Mon Sep 17 00:00:00 2001
From: Iaroslav Postovalov <postovalovya@gmail.com>
Date: Wed, 10 Mar 2021 21:35:28 +0700
Subject: [PATCH 12/37] Revise benchmarks code

Revise benchmarks code by using kotlinx.benchmark type aliases
(it will simplify creating multiplatform benchmarks), using
Blackhole class to consume results, moving all the constant state
to private companion objects
---
 .../kmath/benchmarks/ArrayBenchmark.kt        | 32 +++++++------
 .../kmath/benchmarks/BufferBenchmark.kt       | 10 ++---
 .../kscience/kmath/benchmarks/DotBenchmark.kt | 27 +++++------
 .../ExpressionsInterpretersBenchmark.kt       | 37 ++++++++-------
 .../benchmarks/LinearAlgebraBenchmark.kt      | 19 ++++----
 .../kmath/benchmarks/NDFieldBenchmark.kt      | 28 +++++++-----
 .../kmath/benchmarks/ViktorBenchmark.kt       | 42 ++++++++++-------
 .../kmath/benchmarks/ViktorLogBenchmark.kt    | 45 ++++++++++---------
 8 files changed, 134 insertions(+), 106 deletions(-)

diff --git a/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/ArrayBenchmark.kt b/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/ArrayBenchmark.kt
index 535778844..43b698c03 100644
--- a/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/ArrayBenchmark.kt
+++ b/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/ArrayBenchmark.kt
@@ -1,34 +1,38 @@
 package space.kscience.kmath.benchmarks
 
-import org.openjdk.jmh.annotations.Benchmark
-import org.openjdk.jmh.annotations.Scope
-import org.openjdk.jmh.annotations.State
+import kotlinx.benchmark.Benchmark
+import kotlinx.benchmark.Blackhole
+import kotlinx.benchmark.Scope
+import kotlinx.benchmark.State
 import java.nio.IntBuffer
 
 @State(Scope.Benchmark)
 internal class ArrayBenchmark {
     @Benchmark
-    fun benchmarkArrayRead() {
+    fun benchmarkArrayRead(blackhole: Blackhole) {
         var res = 0
-        for (i in 1..space.kscience.kmath.benchmarks.ArrayBenchmark.Companion.size) res += space.kscience.kmath.benchmarks.ArrayBenchmark.Companion.array[space.kscience.kmath.benchmarks.ArrayBenchmark.Companion.size - i]
+        for (i in 1..size) res += array[size - i]
+        blackhole.consume(res)
     }
 
     @Benchmark
-    fun benchmarkBufferRead() {
+    fun benchmarkBufferRead(blackhole: Blackhole) {
         var res = 0
-        for (i in 1..space.kscience.kmath.benchmarks.ArrayBenchmark.Companion.size) res += space.kscience.kmath.benchmarks.ArrayBenchmark.Companion.arrayBuffer[space.kscience.kmath.benchmarks.ArrayBenchmark.Companion.size - i]
+        for (i in 1..size) res += arrayBuffer[size - i]
+        blackhole.consume(res)
     }
 
     @Benchmark
-    fun nativeBufferRead() {
+    fun nativeBufferRead(blackhole: Blackhole) {
         var res = 0
-        for (i in 1..space.kscience.kmath.benchmarks.ArrayBenchmark.Companion.size) res += space.kscience.kmath.benchmarks.ArrayBenchmark.Companion.nativeBuffer[space.kscience.kmath.benchmarks.ArrayBenchmark.Companion.size - i]
+        for (i in 1..size) res += nativeBuffer[size - i]
+        blackhole.consume(res)
     }
 
-    companion object {
-        const val size: Int = 1000
-        val array: IntArray = IntArray(space.kscience.kmath.benchmarks.ArrayBenchmark.Companion.size) { it }
-        val arrayBuffer: IntBuffer = IntBuffer.wrap(space.kscience.kmath.benchmarks.ArrayBenchmark.Companion.array)
-        val nativeBuffer: IntBuffer = IntBuffer.allocate(space.kscience.kmath.benchmarks.ArrayBenchmark.Companion.size).also { for (i in 0 until space.kscience.kmath.benchmarks.ArrayBenchmark.Companion.size) it.put(i, i) }
+    private companion object {
+        private const val size = 1000
+        private val array = IntArray(size) { it }
+        private val arrayBuffer = IntBuffer.wrap(array)
+        private val nativeBuffer = IntBuffer.allocate(size).also { for (i in 0 until size) it.put(i, i) }
     }
 }
diff --git a/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/BufferBenchmark.kt b/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/BufferBenchmark.kt
index 1afb4e52c..1c3bbab75 100644
--- a/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/BufferBenchmark.kt
+++ b/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/BufferBenchmark.kt
@@ -1,8 +1,8 @@
 package space.kscience.kmath.benchmarks
 
-import org.openjdk.jmh.annotations.Benchmark
-import org.openjdk.jmh.annotations.Scope
-import org.openjdk.jmh.annotations.State
+import kotlinx.benchmark.Benchmark
+import kotlinx.benchmark.Scope
+import kotlinx.benchmark.State
 import space.kscience.kmath.complex.Complex
 import space.kscience.kmath.complex.complex
 import space.kscience.kmath.structures.MutableBuffer
@@ -28,7 +28,7 @@ internal class BufferBenchmark {
         }
     }
 
-    companion object {
-        const val size: Int = 100
+    private companion object {
+        private const val size = 100
     }
 }
diff --git a/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/DotBenchmark.kt b/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/DotBenchmark.kt
index 39eeb24d3..93b5c5549 100644
--- a/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/DotBenchmark.kt
+++ b/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/DotBenchmark.kt
@@ -1,8 +1,9 @@
 package space.kscience.kmath.benchmarks
 
 import kotlinx.benchmark.Benchmark
-import org.openjdk.jmh.annotations.Scope
-import org.openjdk.jmh.annotations.State
+import kotlinx.benchmark.Blackhole
+import kotlinx.benchmark.Scope
+import kotlinx.benchmark.State
 import space.kscience.kmath.commons.linear.CMMatrixContext
 import space.kscience.kmath.ejml.EjmlMatrixContext
 import space.kscience.kmath.linear.BufferMatrixContext
@@ -17,7 +18,7 @@ import kotlin.random.Random
 internal class DotBenchmark {
     companion object {
         val random = Random(12224)
-        val dim = 1000
+        const val dim = 1000
 
         //creating invertible matrix
         val matrix1 = Matrix.real(dim, dim) { i, j -> if (i <= j) random.nextDouble() else 0.0 }
@@ -31,37 +32,37 @@ internal class DotBenchmark {
     }
 
     @Benchmark
-    fun cmDot() {
+    fun cmDot(blackhole: Blackhole) {
         CMMatrixContext {
-            cmMatrix1 dot cmMatrix2
+            blackhole.consume(cmMatrix1 dot cmMatrix2)
         }
     }
 
     @Benchmark
-    fun ejmlDot() {
+    fun ejmlDot(blackhole: Blackhole) {
         EjmlMatrixContext {
-            ejmlMatrix1 dot ejmlMatrix2
+            blackhole.consume(ejmlMatrix1 dot ejmlMatrix2)
         }
     }
 
     @Benchmark
-    fun ejmlDotWithConversion() {
+    fun ejmlDotWithConversion(blackhole: Blackhole) {
         EjmlMatrixContext {
-            matrix1 dot matrix2
+            blackhole.consume(matrix1 dot matrix2)
         }
     }
 
     @Benchmark
-    fun bufferedDot() {
+    fun bufferedDot(blackhole: Blackhole) {
         BufferMatrixContext(RealField, Buffer.Companion::real).invoke {
-            matrix1 dot matrix2
+            blackhole.consume(matrix1 dot matrix2)
         }
     }
 
     @Benchmark
-    fun realDot() {
+    fun realDot(blackhole: Blackhole) {
         RealMatrixContext {
-            matrix1 dot matrix2
+            blackhole.consume(matrix1 dot matrix2)
         }
     }
 }
diff --git a/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/ExpressionsInterpretersBenchmark.kt b/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/ExpressionsInterpretersBenchmark.kt
index a9c0fe703..9c150f074 100644
--- a/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/ExpressionsInterpretersBenchmark.kt
+++ b/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/ExpressionsInterpretersBenchmark.kt
@@ -1,64 +1,62 @@
 package space.kscience.kmath.benchmarks
 
-import org.openjdk.jmh.annotations.Benchmark
-import org.openjdk.jmh.annotations.Scope
-import org.openjdk.jmh.annotations.State
+import kotlinx.benchmark.Benchmark
+import kotlinx.benchmark.Blackhole
+import kotlinx.benchmark.Scope
+import kotlinx.benchmark.State
 import space.kscience.kmath.asm.compile
 import space.kscience.kmath.ast.mstInField
 import space.kscience.kmath.expressions.Expression
 import space.kscience.kmath.expressions.expressionInField
 import space.kscience.kmath.expressions.invoke
 import space.kscience.kmath.expressions.symbol
-import space.kscience.kmath.operations.Field
 import space.kscience.kmath.operations.RealField
 import space.kscience.kmath.operations.bindSymbol
 import kotlin.random.Random
 
 @State(Scope.Benchmark)
 internal class ExpressionsInterpretersBenchmark {
-    private val algebra: Field<Double> = RealField
-    val x by symbol
-
     @Benchmark
-    fun functionalExpression() {
+    fun functionalExpression(blackhole: Blackhole) {
         val expr = algebra.expressionInField {
             val x = bindSymbol(x)
             x * const(2.0) + const(2.0) / x - const(16.0)
         }
 
-        invokeAndSum(expr)
+        invokeAndSum(expr, blackhole)
     }
 
     @Benchmark
-    fun mstExpression() {
+    fun mstExpression(blackhole: Blackhole) {
         val expr = algebra.mstInField {
             val x = bindSymbol(x)
             x * 2.0 + 2.0 / x - 16.0
         }
 
-        invokeAndSum(expr)
+        invokeAndSum(expr, blackhole)
     }
 
     @Benchmark
-    fun asmExpression() {
+    fun asmExpression(blackhole: Blackhole) {
         val expr = algebra.mstInField {
             val x = bindSymbol(x)
             x * 2.0 + 2.0 / x - 16.0
         }.compile()
 
-        invokeAndSum(expr)
+        invokeAndSum(expr, blackhole)
     }
 
     @Benchmark
-    fun rawExpression() {
+    fun rawExpression(blackhole: Blackhole) {
         val expr = Expression<Double> { args ->
             val x = args.getValue(x)
             x * 2.0 + 2.0 / x - 16.0
         }
-        invokeAndSum(expr)
+
+        invokeAndSum(expr, blackhole)
     }
 
-    private fun invokeAndSum(expr: Expression<Double>) {
+    private fun invokeAndSum(expr: Expression<Double>, blackhole: Blackhole) {
         val random = Random(0)
         var sum = 0.0
 
@@ -66,6 +64,11 @@ internal class ExpressionsInterpretersBenchmark {
             sum += expr(x to random.nextDouble())
         }
 
-        println(sum)
+        blackhole.consume(sum)
+    }
+
+    private companion object {
+        private val algebra = RealField
+        private val x by symbol
     }
 }
diff --git a/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/LinearAlgebraBenchmark.kt b/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/LinearAlgebraBenchmark.kt
index 22e735e12..30cb6c0b9 100644
--- a/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/LinearAlgebraBenchmark.kt
+++ b/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/LinearAlgebraBenchmark.kt
@@ -1,8 +1,9 @@
 package space.kscience.kmath.benchmarks
 
 import kotlinx.benchmark.Benchmark
-import org.openjdk.jmh.annotations.Scope
-import org.openjdk.jmh.annotations.State
+import kotlinx.benchmark.Blackhole
+import kotlinx.benchmark.Scope
+import kotlinx.benchmark.State
 import space.kscience.kmath.commons.linear.CMMatrixContext
 import space.kscience.kmath.commons.linear.CMMatrixContext.dot
 import space.kscience.kmath.commons.linear.inverse
@@ -18,7 +19,7 @@ import kotlin.random.Random
 internal class LinearAlgebraBenchmark {
     companion object {
         val random = Random(1224)
-        val dim = 100
+        const val dim = 100
 
         //creating invertible matrix
         val u = Matrix.real(dim, dim) { i, j -> if (i <= j) random.nextDouble() else 0.0 }
@@ -27,21 +28,21 @@ internal class LinearAlgebraBenchmark {
     }
 
     @Benchmark
-    fun kmathLupInversion() {
-        MatrixContext.real.inverseWithLup(matrix)
+    fun kmathLupInversion(blackhole: Blackhole) {
+        blackhole.consume(MatrixContext.real.inverseWithLup(matrix))
     }
 
     @Benchmark
-    fun cmLUPInversion() {
+    fun cmLUPInversion(blackhole: Blackhole) {
         with(CMMatrixContext) {
-            inverse(matrix)
+            blackhole.consume(inverse(matrix))
         }
     }
 
     @Benchmark
-    fun ejmlInverse() {
+    fun ejmlInverse(blackhole: Blackhole) {
         with(EjmlMatrixContext) {
-            inverse(matrix)
+            blackhole.consume(inverse(matrix))
         }
     }
 }
diff --git a/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/NDFieldBenchmark.kt b/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/NDFieldBenchmark.kt
index 5bcc09cdb..aeee0dafe 100644
--- a/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/NDFieldBenchmark.kt
+++ b/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/NDFieldBenchmark.kt
@@ -1,8 +1,9 @@
 package space.kscience.kmath.benchmarks
 
-import org.openjdk.jmh.annotations.Benchmark
-import org.openjdk.jmh.annotations.Scope
-import org.openjdk.jmh.annotations.State
+import kotlinx.benchmark.Benchmark
+import kotlinx.benchmark.Blackhole
+import kotlinx.benchmark.Scope
+import kotlinx.benchmark.State
 import space.kscience.kmath.nd.*
 import space.kscience.kmath.operations.RealField
 import space.kscience.kmath.structures.Buffer
@@ -10,35 +11,38 @@ import space.kscience.kmath.structures.Buffer
 @State(Scope.Benchmark)
 internal class NDFieldBenchmark {
     @Benchmark
-    fun autoFieldAdd() {
+    fun autoFieldAdd(blackhole: Blackhole) {
         with(autoField) {
             var res: NDStructure<Double> = one
             repeat(n) { res += one }
+            blackhole.consume(res)
         }
     }
 
     @Benchmark
-    fun specializedFieldAdd() {
+    fun specializedFieldAdd(blackhole: Blackhole) {
         with(specializedField) {
             var res: NDStructure<Double> = one
             repeat(n) { res += 1.0 }
+            blackhole.consume(res)
         }
     }
 
 
     @Benchmark
-    fun boxingFieldAdd() {
+    fun boxingFieldAdd(blackhole: Blackhole) {
         with(genericField) {
             var res: NDStructure<Double> = one
             repeat(n) { res += 1.0 }
+            blackhole.consume(res)
         }
     }
 
-    companion object {
-        const val dim: Int = 1000
-        const val n: Int = 100
-        val autoField = NDAlgebra.auto(RealField, dim, dim)
-        val specializedField: RealNDField = NDAlgebra.real(dim, dim)
-        val genericField = NDAlgebra.field(RealField, Buffer.Companion::boxing, dim, dim)
+    private companion object {
+        private const val dim = 1000
+        private const val n = 100
+        private val autoField = NDAlgebra.auto(RealField, dim, dim)
+        private val specializedField = NDAlgebra.real(dim, dim)
+        private val genericField = NDAlgebra.field(RealField, Buffer.Companion::boxing, dim, dim)
     }
 }
diff --git a/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/ViktorBenchmark.kt b/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/ViktorBenchmark.kt
index 370258bc6..c511173a9 100644
--- a/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/ViktorBenchmark.kt
+++ b/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/ViktorBenchmark.kt
@@ -1,51 +1,61 @@
 package space.kscience.kmath.benchmarks
 
+import kotlinx.benchmark.Benchmark
+import kotlinx.benchmark.Blackhole
+import kotlinx.benchmark.Scope
+import kotlinx.benchmark.State
 import org.jetbrains.bio.viktor.F64Array
-import org.openjdk.jmh.annotations.Benchmark
-import org.openjdk.jmh.annotations.Scope
-import org.openjdk.jmh.annotations.State
-import space.kscience.kmath.nd.*
+import space.kscience.kmath.nd.NDAlgebra
+import space.kscience.kmath.nd.NDStructure
+import space.kscience.kmath.nd.auto
+import space.kscience.kmath.nd.real
 import space.kscience.kmath.operations.RealField
 import space.kscience.kmath.viktor.ViktorNDField
 
 @State(Scope.Benchmark)
 internal class ViktorBenchmark {
-    final val dim: Int = 1000
-    final val n: Int = 100
-
-    // automatically build context most suited for given type.
-    final val autoField: NDField<Double, RealField> = NDAlgebra.auto(RealField, dim, dim)
-    final val realField: RealNDField = NDAlgebra.real(dim, dim)
-    final val viktorField: ViktorNDField = ViktorNDField(dim, dim)
-
     @Benchmark
-    fun automaticFieldAddition() {
+    fun automaticFieldAddition(blackhole: Blackhole) {
         with(autoField) {
             var res: NDStructure<Double> = one
             repeat(n) { res += 1.0 }
+            blackhole.consume(res)
         }
     }
 
     @Benchmark
-    fun realFieldAddition() {
+    fun realFieldAddition(blackhole: Blackhole) {
         with(realField) {
             var res: NDStructure<Double> = one
             repeat(n) { res += 1.0 }
+            blackhole.consume(res)
         }
     }
 
     @Benchmark
-    fun viktorFieldAddition() {
+    fun viktorFieldAddition(blackhole: Blackhole) {
         with(viktorField) {
             var res = one
             repeat(n) { res += 1.0 }
+            blackhole.consume(res)
         }
     }
 
     @Benchmark
-    fun rawViktor() {
+    fun rawViktor(blackhole: Blackhole) {
         val one = F64Array.full(init = 1.0, shape = intArrayOf(dim, dim))
         var res = one
         repeat(n) { res = res + one }
+        blackhole.consume(res)
+    }
+
+    private companion object {
+        private const val dim = 1000
+        private const val n = 100
+
+        // automatically build context most suited for given type.
+        private val autoField = NDAlgebra.auto(RealField, dim, dim)
+        private val realField = NDAlgebra.real(dim, dim)
+        private val viktorField = ViktorNDField(dim, dim)
     }
 }
diff --git a/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/ViktorLogBenchmark.kt b/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/ViktorLogBenchmark.kt
index 9f99b002a..c48c86af9 100644
--- a/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/ViktorLogBenchmark.kt
+++ b/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/ViktorLogBenchmark.kt
@@ -1,48 +1,53 @@
 package space.kscience.kmath.benchmarks
 
+import kotlinx.benchmark.Benchmark
+import kotlinx.benchmark.Blackhole
+import kotlinx.benchmark.Scope
+import kotlinx.benchmark.State
 import org.jetbrains.bio.viktor.F64Array
-import org.openjdk.jmh.annotations.Benchmark
-import org.openjdk.jmh.annotations.Scope
-import org.openjdk.jmh.annotations.State
-import space.kscience.kmath.nd.*
+import space.kscience.kmath.nd.NDAlgebra
+import space.kscience.kmath.nd.auto
+import space.kscience.kmath.nd.real
 import space.kscience.kmath.operations.RealField
 import space.kscience.kmath.viktor.ViktorNDField
 
 @State(Scope.Benchmark)
 internal class ViktorLogBenchmark {
-    final val dim: Int = 1000
-    final val n: Int = 100
-
-    // automatically build context most suited for given type.
-    final val autoField: NDField<Double, RealField> = NDAlgebra.auto(RealField, dim, dim)
-    final val realField: RealNDField = NDAlgebra.real(dim, dim)
-    final val viktorField: ViktorNDField = ViktorNDField(intArrayOf(dim, dim))
-
-
     @Benchmark
-    fun realFieldLog() {
+    fun realFieldLog(blackhole: Blackhole) {
         with(realField) {
             val fortyTwo = produce { 42.0 }
             var res = one
             repeat(n) { res = ln(fortyTwo) }
+            blackhole.consume(res)
         }
     }
 
     @Benchmark
-    fun viktorFieldLog() {
+    fun viktorFieldLog(blackhole: Blackhole) {
         with(viktorField) {
             val fortyTwo = produce { 42.0 }
             var res = one
             repeat(n) { res = ln(fortyTwo) }
+            blackhole.consume(res)
         }
     }
 
     @Benchmark
-    fun rawViktorLog() {
+    fun rawViktorLog(blackhole: Blackhole) {
         val fortyTwo = F64Array.full(dim, dim, init = 42.0)
-        var res: F64Array
-        repeat(n) {
-            res = fortyTwo.log()
-        }
+        lateinit var res: F64Array
+        repeat(n) { res = fortyTwo.log() }
+        blackhole.consume(res)
+    }
+
+    private companion object {
+        private const val dim = 1000
+        private const val n = 100
+
+        // automatically build context most suited for given type.
+        private val autoField = NDAlgebra.auto(RealField, dim, dim)
+        private val realField = NDAlgebra.real(dim, dim)
+        private val viktorField = ViktorNDField(intArrayOf(dim, dim))
     }
 }
-- 
2.34.1


From 6a5ca2a115570c404b7fa0be7885cd2d539e60e5 Mon Sep 17 00:00:00 2001
From: Alexander Nozik <altavir@gmail.com>
Date: Wed, 10 Mar 2021 18:02:04 +0300
Subject: [PATCH 13/37] Code review.

---
 CHANGELOG.md                                  |   2 +-
 build.gradle.kts                              |   1 +
 .../space/kscience/kmath/ast/expressions.kt   |   3 +-
 .../kmath/linear/RealMatrixContext.kt         |  12 ++-
 .../kmath/operations/NumericAlgebra.kt        |   2 +-
 .../kscience/kmath/functions/Polynomial.kt    |   6 +-
 .../kmath/interpolation/SplineInterpolator.kt |   4 +-
 .../kscience/kmath/nd4j/Nd4jArrayAlgebra.kt   | 100 +++++++-----------
 .../kmath/viktor/ViktorNDStructure.kt         |   2 +-
 9 files changed, 58 insertions(+), 74 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index db3b65024..595cd3bbc 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,8 +2,8 @@
 
 ## [Unreleased]
 ### Added
-- Intrinsic value `two` for ExtendedField to work with hyperbolic functions
 - ScaleOperations interface
+- Field extends ScaleOperations
 
 ### Changed
 - Exponential operations merged with hyperbolic functions
diff --git a/build.gradle.kts b/build.gradle.kts
index 41e8a3468..113107f69 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -34,6 +34,7 @@ readme {
 ksciencePublish {
     github("kmath")
     space()
+    sonatype()
 }
 
 apiValidation {
diff --git a/examples/src/main/kotlin/space/kscience/kmath/ast/expressions.kt b/examples/src/main/kotlin/space/kscience/kmath/ast/expressions.kt
index 8d6851ef8..1cafe30c1 100644
--- a/examples/src/main/kotlin/space/kscience/kmath/ast/expressions.kt
+++ b/examples/src/main/kotlin/space/kscience/kmath/ast/expressions.kt
@@ -1,12 +1,11 @@
 package space.kscience.kmath.ast
 
-import space.kscience.kmath.expressions.invoke
 import space.kscience.kmath.operations.RealField
 
 fun main() {
     val expr = RealField.mstInField {
         val x = bindSymbol("x")
-        x * 2.0 + 2.0 * one / x - 16.0
+        x * 2.0 + number(2.0) / x - 16.0
     }
 
     repeat(10000000) {
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/RealMatrixContext.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/RealMatrixContext.kt
index a53f0837f..dbccb7536 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/RealMatrixContext.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/RealMatrixContext.kt
@@ -1,8 +1,9 @@
 package space.kscience.kmath.linear
 
+import space.kscience.kmath.operations.ScaleOperations
 import space.kscience.kmath.structures.RealBuffer
 
-public object RealMatrixContext : MatrixContext<Double, BufferMatrix<Double>> {
+public object RealMatrixContext : MatrixContext<Double, BufferMatrix<Double>>, ScaleOperations<Matrix<Double>> {
 
     public override fun produce(
         rows: Int,
@@ -58,10 +59,13 @@ public object RealMatrixContext : MatrixContext<Double, BufferMatrix<Double>> {
         }
     }
 
-    override fun Matrix<Double>.times(value: Double): BufferMatrix<Double> {
-        val bufferMatrix = toBufferMatrix()
-        return produce(rowNum, colNum) { i, j -> bufferMatrix[i, j] * value }
+    override fun scale(a: Matrix<Double>, value: Double): BufferMatrix<Double> {
+        val bufferMatrix = a.toBufferMatrix()
+        return produce(a.rowNum, a.colNum) { i, j -> bufferMatrix[i, j] * value }
     }
+
+    override fun Matrix<Double>.times(value: Double): BufferMatrix<Double> = scale(this, value)
+
 //
 //    override fun multiply(a: Matrix<Double>, k: Number): BufferMatrix<Double> {
 //        val aBufferMatrix = a.toBufferMatrix()
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/NumericAlgebra.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/NumericAlgebra.kt
index 187261b1d..5f6ec869a 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/NumericAlgebra.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/NumericAlgebra.kt
@@ -86,7 +86,7 @@ public interface NumericAlgebra<T> : Algebra<T> {
  */
 public interface ScaleOperations<T> : Algebra<T> {
     /**
-     * Scaling of element by scalar.
+     * Scaling an element by a scalar.
      *
      * @param a the multiplier.
      * @param value the multiplicand.
diff --git a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/Polynomial.kt b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/Polynomial.kt
index 7416069bd..9141fa7b9 100644
--- a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/Polynomial.kt
+++ b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/Polynomial.kt
@@ -42,9 +42,9 @@ public fun <T : Any, C : Ring<T>> Polynomial<T>.asFunction(ring: C): (T) -> T =
 /**
  * An algebra for polynomials
  */
-public class PolynomialSpace<T : Any, C >(
+public class PolynomialSpace<T : Any, C>(
     private val ring: C,
-) : Space<Polynomial<T>>, ScaleOperations<Polynomial<T>> where C: Ring<T>, C: ScaleOperations<T>{
+) : Space<Polynomial<T>>, ScaleOperations<Polynomial<T>> where C : Ring<T>, C : ScaleOperations<T> {
     public override val zero: Polynomial<T> = Polynomial(emptyList())
 
     override fun Polynomial<T>.unaryMinus(): Polynomial<T> = with(ring) {
@@ -67,7 +67,7 @@ public class PolynomialSpace<T : Any, C >(
     public operator fun Polynomial<T>.invoke(arg: T): T = value(ring, arg)
 }
 
-public inline fun <T : Any, C, R> C.polynomial(block: PolynomialSpace<T, C>.() -> R): R where C: Ring<T>, C: ScaleOperations<T>{
+public inline fun <T : Any, C, R> C.polynomial(block: PolynomialSpace<T, C>.() -> R): R where C : Ring<T>, C : ScaleOperations<T> {
     contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) }
     return PolynomialSpace(this).block()
 }
diff --git a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/interpolation/SplineInterpolator.kt b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/interpolation/SplineInterpolator.kt
index 78d6e0d0c..ddbe743f0 100644
--- a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/interpolation/SplineInterpolator.kt
+++ b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/interpolation/SplineInterpolator.kt
@@ -11,8 +11,8 @@ import space.kscience.kmath.structures.MutableBufferFactory
  * Generic spline interpolator. Not recommended for performance critical places, use platform-specific and type specific ones.
  * Based on https://github.com/apache/commons-math/blob/eb57d6d457002a0bb5336d789a3381a24599affe/src/main/java/org/apache/commons/math4/analysis/interpolation/SplineInterpolator.java
  */
-public class SplineInterpolator<T : Comparable<T>, F : Field<T>>(
-    public override val algebra: F,
+public class SplineInterpolator<T : Comparable<T>>(
+    public override val algebra: Field<T>,
     public val bufferFactory: MutableBufferFactory<T>,
 ) : PolynomialInterpolator<T> {
     //TODO possibly optimize zeroed buffers
diff --git a/kmath-nd4j/src/main/kotlin/space/kscience/kmath/nd4j/Nd4jArrayAlgebra.kt b/kmath-nd4j/src/main/kotlin/space/kscience/kmath/nd4j/Nd4jArrayAlgebra.kt
index 11e7b73e4..dea74abdc 100644
--- a/kmath-nd4j/src/main/kotlin/space/kscience/kmath/nd4j/Nd4jArrayAlgebra.kt
+++ b/kmath-nd4j/src/main/kotlin/space/kscience/kmath/nd4j/Nd4jArrayAlgebra.kt
@@ -80,21 +80,17 @@ public interface Nd4jArraySpace<T, S : Space<T>> : NDSpace<T, S>, Nd4jArrayAlgeb
     public override val zero: Nd4jArrayStructure<T>
         get() = Nd4j.zeros(*shape).wrap()
 
-    public override fun add(a: NDStructure<T>, b: NDStructure<T>): Nd4jArrayStructure<T> {
-        return a.ndArray.add(b.ndArray).wrap()
-    }
+    public override fun add(a: NDStructure<T>, b: NDStructure<T>): Nd4jArrayStructure<T> =
+        a.ndArray.add(b.ndArray).wrap()
 
-    public override operator fun NDStructure<T>.minus(b: NDStructure<T>): Nd4jArrayStructure<T> {
-        return ndArray.sub(b.ndArray).wrap()
-    }
+    public override operator fun NDStructure<T>.minus(b: NDStructure<T>): Nd4jArrayStructure<T> =
+        ndArray.sub(b.ndArray).wrap()
 
-    public override operator fun NDStructure<T>.unaryMinus(): Nd4jArrayStructure<T> {
-        return ndArray.neg().wrap()
-    }
+    public override operator fun NDStructure<T>.unaryMinus(): Nd4jArrayStructure<T> =
+        ndArray.neg().wrap()
 
-    public fun multiply(a: NDStructure<T>, k: Number): Nd4jArrayStructure<T> {
-        return a.ndArray.mul(k).wrap()
-    }
+    public fun multiply(a: NDStructure<T>, k: Number): Nd4jArrayStructure<T> =
+        a.ndArray.mul(k).wrap()
 }
 
 /**
@@ -109,9 +105,8 @@ public interface Nd4jArrayRing<T, R : Ring<T>> : NDRing<T, R>, Nd4jArraySpace<T,
     public override val one: Nd4jArrayStructure<T>
         get() = Nd4j.ones(*shape).wrap()
 
-    public override fun multiply(a: NDStructure<T>, b: NDStructure<T>): Nd4jArrayStructure<T> {
-        return a.ndArray.mul(b.ndArray).wrap()
-    }
+    public override fun multiply(a: NDStructure<T>, b: NDStructure<T>): Nd4jArrayStructure<T> =
+        a.ndArray.mul(b.ndArray).wrap()
 //
 //    public override operator fun Nd4jArrayStructure<T>.minus(b: Number): Nd4jArrayStructure<T> {
 //        check(this)
@@ -250,33 +245,26 @@ public class FloatNd4jArrayField(public override val shape: IntArray) : Nd4jArra
 
     public override fun INDArray.wrap(): Nd4jArrayStructure<Float> = checkShape(this).asFloatStructure()
 
-    override fun scale(a: NDStructure<Float>, value: Double): NDStructure<Float> {
-        return a.ndArray.mul(value).wrap()
-    }
+    override fun scale(a: NDStructure<Float>, value: Double): NDStructure<Float> =
+        a.ndArray.mul(value).wrap()
 
-    public override operator fun NDStructure<Float>.div(arg: Float): Nd4jArrayStructure<Float> {
-        return ndArray.div(arg).wrap()
-    }
+    public override operator fun NDStructure<Float>.div(arg: Float): Nd4jArrayStructure<Float> =
+        ndArray.div(arg).wrap()
 
-    public override operator fun NDStructure<Float>.plus(arg: Float): Nd4jArrayStructure<Float> {
-        return ndArray.add(arg).wrap()
-    }
+    public override operator fun NDStructure<Float>.plus(arg: Float): Nd4jArrayStructure<Float> =
+        ndArray.add(arg).wrap()
 
-    public override operator fun NDStructure<Float>.minus(arg: Float): Nd4jArrayStructure<Float> {
-        return ndArray.sub(arg).wrap()
-    }
+    public override operator fun NDStructure<Float>.minus(arg: Float): Nd4jArrayStructure<Float> =
+        ndArray.sub(arg).wrap()
 
-    public override operator fun NDStructure<Float>.times(arg: Float): Nd4jArrayStructure<Float> {
-        return ndArray.mul(arg).wrap()
-    }
+    public override operator fun NDStructure<Float>.times(arg: Float): Nd4jArrayStructure<Float> =
+        ndArray.mul(arg).wrap()
 
-    public override operator fun Float.div(arg: NDStructure<Float>): Nd4jArrayStructure<Float> {
-        return arg.ndArray.rdiv(this).wrap()
-    }
+    public override operator fun Float.div(arg: NDStructure<Float>): Nd4jArrayStructure<Float> =
+        arg.ndArray.rdiv(this).wrap()
 
-    public override operator fun Float.minus(arg: NDStructure<Float>): Nd4jArrayStructure<Float> {
-        return arg.ndArray.rsub(this).wrap()
-    }
+    public override operator fun Float.minus(arg: NDStructure<Float>): Nd4jArrayStructure<Float> =
+        arg.ndArray.rsub(this).wrap()
 }
 
 /**
@@ -288,21 +276,17 @@ public class IntNd4jArrayRing(public override val shape: IntArray) : Nd4jArrayRi
 
     public override fun INDArray.wrap(): Nd4jArrayStructure<Int> = checkShape(this).asIntStructure()
 
-    public override operator fun NDStructure<Int>.plus(arg: Int): Nd4jArrayStructure<Int> {
-        return ndArray.add(arg).wrap()
-    }
+    public override operator fun NDStructure<Int>.plus(arg: Int): Nd4jArrayStructure<Int> =
+        ndArray.add(arg).wrap()
 
-    public override operator fun NDStructure<Int>.minus(arg: Int): Nd4jArrayStructure<Int> {
-        return ndArray.sub(arg).wrap()
-    }
+    public override operator fun NDStructure<Int>.minus(arg: Int): Nd4jArrayStructure<Int> =
+        ndArray.sub(arg).wrap()
 
-    public override operator fun NDStructure<Int>.times(arg: Int): Nd4jArrayStructure<Int> {
-        return ndArray.mul(arg).wrap()
-    }
+    public override operator fun NDStructure<Int>.times(arg: Int): Nd4jArrayStructure<Int> =
+        ndArray.mul(arg).wrap()
 
-    public override operator fun Int.minus(arg: NDStructure<Int>): Nd4jArrayStructure<Int> {
-        return arg.ndArray.rsub(this).wrap()
-    }
+    public override operator fun Int.minus(arg: NDStructure<Int>): Nd4jArrayStructure<Int> =
+        arg.ndArray.rsub(this).wrap()
 }
 
 /**
@@ -314,19 +298,15 @@ public class LongNd4jArrayRing(public override val shape: IntArray) : Nd4jArrayR
 
     public override fun INDArray.wrap(): Nd4jArrayStructure<Long> = checkShape(this).asLongStructure()
 
-    public override operator fun NDStructure<Long>.plus(arg: Long): Nd4jArrayStructure<Long> {
-        return ndArray.add(arg).wrap()
-    }
+    public override operator fun NDStructure<Long>.plus(arg: Long): Nd4jArrayStructure<Long> =
+        ndArray.add(arg).wrap()
 
-    public override operator fun NDStructure<Long>.minus(arg: Long): Nd4jArrayStructure<Long> {
-        return ndArray.sub(arg).wrap()
-    }
+    public override operator fun NDStructure<Long>.minus(arg: Long): Nd4jArrayStructure<Long> =
+        ndArray.sub(arg).wrap()
 
-    public override operator fun NDStructure<Long>.times(arg: Long): Nd4jArrayStructure<Long> {
-        return ndArray.mul(arg).wrap()
-    }
+    public override operator fun NDStructure<Long>.times(arg: Long): Nd4jArrayStructure<Long> =
+        ndArray.mul(arg).wrap()
 
-    public override operator fun Long.minus(arg: NDStructure<Long>): Nd4jArrayStructure<Long> {
-        return arg.ndArray.rsub(this).wrap()
-    }
+    public override operator fun Long.minus(arg: NDStructure<Long>): Nd4jArrayStructure<Long> =
+        arg.ndArray.rsub(this).wrap()
 }
diff --git a/kmath-viktor/src/main/kotlin/space/kscience/kmath/viktor/ViktorNDStructure.kt b/kmath-viktor/src/main/kotlin/space/kscience/kmath/viktor/ViktorNDStructure.kt
index 218afcbef..f5697cea2 100644
--- a/kmath-viktor/src/main/kotlin/space/kscience/kmath/viktor/ViktorNDStructure.kt
+++ b/kmath-viktor/src/main/kotlin/space/kscience/kmath/viktor/ViktorNDStructure.kt
@@ -57,7 +57,7 @@ public class ViktorNDField(public override val shape: IntArray) : NDField<Double
             }
         }.asStructure()
 
-    override fun NDStructure<Double>.unaryMinus(): NDStructure<Double> = this * (-1)
+    override fun NDStructure<Double>.unaryMinus(): NDStructure<Double> = -1 * this
 
     public override fun NDStructure<Double>.map(transform: RealField.(Double) -> Double): ViktorNDStructure =
         F64Array(*this@ViktorNDField.shape).apply {
-- 
2.34.1


From fe95c4e48ed60716b60e446d26aca6083a7a83a2 Mon Sep 17 00:00:00 2001
From: Alexander Nozik <altavir@gmail.com>
Date: Wed, 10 Mar 2021 18:20:23 +0300
Subject: [PATCH 14/37] Code review.

---
 .../kotlin/space/kscience/kmath/ast/expressions.kt     |  1 +
 kmath-core/api/kmath-core.api                          | 10 +++++++++-
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/examples/src/main/kotlin/space/kscience/kmath/ast/expressions.kt b/examples/src/main/kotlin/space/kscience/kmath/ast/expressions.kt
index 1cafe30c1..c342fc3ef 100644
--- a/examples/src/main/kotlin/space/kscience/kmath/ast/expressions.kt
+++ b/examples/src/main/kotlin/space/kscience/kmath/ast/expressions.kt
@@ -1,5 +1,6 @@
 package space.kscience.kmath.ast
 
+import space.kscience.kmath.expressions.invoke
 import space.kscience.kmath.operations.RealField
 
 fun main() {
diff --git a/kmath-core/api/kmath-core.api b/kmath-core/api/kmath-core.api
index 0efe430ad..da4725428 100644
--- a/kmath-core/api/kmath-core.api
+++ b/kmath-core/api/kmath-core.api
@@ -697,7 +697,7 @@ public abstract interface class space/kscience/kmath/linear/QRDecompositionFeatu
 	public abstract fun getR ()Lspace/kscience/kmath/nd/Structure2D;
 }
 
-public final class space/kscience/kmath/linear/RealMatrixContext : space/kscience/kmath/linear/MatrixContext {
+public final class space/kscience/kmath/linear/RealMatrixContext : space/kscience/kmath/linear/MatrixContext, space/kscience/kmath/operations/ScaleOperations {
 	public static final field INSTANCE Lspace/kscience/kmath/linear/RealMatrixContext;
 	public synthetic fun add (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun add (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/linear/BufferMatrix;
@@ -706,6 +706,8 @@ public final class space/kscience/kmath/linear/RealMatrixContext : space/kscienc
 	public fun binaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public synthetic fun bindSymbol (Ljava/lang/String;)Ljava/lang/Object;
 	public fun bindSymbol (Ljava/lang/String;)Lspace/kscience/kmath/nd/Structure2D;
+	public synthetic fun div (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
+	public fun div (Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Number;)Lspace/kscience/kmath/nd/Structure2D;
 	public fun dot (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/linear/BufferMatrix;
 	public synthetic fun dot (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
 	public fun dot (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
@@ -717,9 +719,15 @@ public final class space/kscience/kmath/linear/RealMatrixContext : space/kscienc
 	public fun point (ILkotlin/jvm/functions/Function1;)Lspace/kscience/kmath/structures/Buffer;
 	public fun produce (IILkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/linear/BufferMatrix;
 	public synthetic fun produce (IILkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/nd/Structure2D;
+	public synthetic fun scale (Ljava/lang/Object;D)Ljava/lang/Object;
+	public fun scale (Lspace/kscience/kmath/nd/Structure2D;D)Lspace/kscience/kmath/linear/BufferMatrix;
 	public fun times (DLspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/linear/BufferMatrix;
+	public synthetic fun times (Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
+	public fun times (Ljava/lang/Number;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
+	public synthetic fun times (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public synthetic fun times (Ljava/lang/Object;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
 	public fun times (Lspace/kscience/kmath/nd/Structure2D;D)Lspace/kscience/kmath/linear/BufferMatrix;
+	public fun times (Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Number;)Lspace/kscience/kmath/nd/Structure2D;
 	public synthetic fun times (Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Object;)Lspace/kscience/kmath/nd/Structure2D;
 	public final fun toBufferMatrix (Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/linear/BufferMatrix;
 	public synthetic fun unaryMinus (Ljava/lang/Object;)Ljava/lang/Object;
-- 
2.34.1


From 39b41cc2ae0b8c7071c42fe50b8cd08b1016e15f Mon Sep 17 00:00:00 2001
From: Iaroslav Postovalov <postovalovya@gmail.com>
Date: Wed, 10 Mar 2021 22:40:43 +0700
Subject: [PATCH 15/37] Fix #223

---
 .../kotlin/space/kscience/kmath/operations/Algebra.kt           | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/Algebra.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/Algebra.kt
index 572f7089a..6bb7d5ed7 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/Algebra.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/Algebra.kt
@@ -188,7 +188,7 @@ public interface SpaceOperations<T> : Algebra<T> {
     public operator fun Number.times(b: T): T = b * this
 
     public override fun unaryOperationFunction(operation: String): (arg: T) -> T = when (operation) {
-        PLUS_OPERATION -> { arg -> arg }
+        PLUS_OPERATION -> { arg -> +arg }
         MINUS_OPERATION -> { arg -> -arg }
         else -> super.unaryOperationFunction(operation)
     }
-- 
2.34.1


From 522f39cef3f75efe11d5e323a3ada955da9d6f7a Mon Sep 17 00:00:00 2001
From: Alexander Nozik <altavir@gmail.com>
Date: Wed, 10 Mar 2021 22:09:19 +0300
Subject: [PATCH 16/37] replace Space by Group

---
 CHANGELOG.md                                  |   1 +
 .../space/kscience/kmath/ast/MstAlgebra.kt    |  34 +--
 .../space/kscience/kmath/ast/MstExpression.kt |  10 +-
 .../TestESTreeConsistencyWithInterpreter.kt   |   4 +-
 .../kotlin/space/kscience/kmath/ast/parser.kt |   8 +-
 .../asm/TestAsmConsistencyWithInterpreter.kt  |   4 +-
 kmath-core/api/kmath-core.api                 | 260 +++++++++---------
 .../FunctionalExpressionAlgebra.kt            |  20 +-
 .../kmath/expressions/expressionBuilders.kt   |   8 +-
 .../kscience/kmath/linear/MatrixContext.kt    |   2 +-
 .../kscience/kmath/linear/VectorSpace.kt      |  14 +-
 .../space/kscience/kmath/misc/cumulative.kt   |   8 +-
 .../kscience/kmath/nd/BufferNDAlgebra.kt      |  14 +-
 .../space/kscience/kmath/nd/NDAlgebra.kt      |  20 +-
 .../kscience/kmath/operations/Algebra.kt      |  11 +-
 .../kmath/operations/AlgebraElements.kt       |   6 +-
 .../kmath/operations/NumericAlgebra.kt        |   2 +-
 .../kmath/operations/algebraExtensions.kt     |  30 +-
 .../kscience/kmath/testutils/SpaceVerifier.kt |   4 +-
 .../space/kscience/kmath/chains/flowExtra.kt  |  10 +-
 .../kscience/kmath/functions/Polynomial.kt    |   4 +-
 .../kscience/kmath/geometry/GeometrySpace.kt  |   4 +-
 .../space/kscience/kmath/histogram/Counter.kt |   4 +-
 .../kmath/histogram/IndexedHistogramSpace.kt  |   4 +-
 .../kmath/histogram/TreeHistogramSpace.kt     |   4 +-
 .../kmath/histogram/UnivariateHistogram.kt    |   4 +-
 .../kmath/kotlingrad/ScalarsAdapters.kt       |   8 +-
 .../kscience/kmath/nd4j/Nd4jArrayAlgebra.kt   |   6 +-
 .../kscience/kmath/stat/SamplerAlgebra.kt     |   6 +-
 .../space/kscience/kmath/stat/Statistic.kt    |   2 +-
 30 files changed, 258 insertions(+), 258 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 595cd3bbc..a172eb69a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,7 @@
 
 ### Changed
 - Exponential operations merged with hyperbolic functions
+- Space is replaced by Group. Space is reserved for vector spaces.
 
 ### Deprecated
 
diff --git a/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/MstAlgebra.kt b/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/MstAlgebra.kt
index 047ee187d..a65027147 100644
--- a/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/MstAlgebra.kt
+++ b/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/MstAlgebra.kt
@@ -18,22 +18,22 @@ public object MstAlgebra : NumericAlgebra<MST> {
 }
 
 /**
- * [Space] over [MST] nodes.
+ * [Group] over [MST] nodes.
  */
-public object MstSpace : Space<MST>, NumericAlgebra<MST>, ScaleOperations<MST> {
+public object MstGroup : Group<MST>, NumericAlgebra<MST>, ScaleOperations<MST> {
     public override val zero: MST.Numeric = number(0.0)
 
     public override fun number(value: Number): MST.Numeric = MstAlgebra.number(value)
     public override fun bindSymbol(value: String): MST.Symbolic = MstAlgebra.bindSymbol(value)
-    public override fun add(a: MST, b: MST): MST.Binary = binaryOperationFunction(SpaceOperations.PLUS_OPERATION)(a, b)
+    public override fun add(a: MST, b: MST): MST.Binary = binaryOperationFunction(GroupOperations.PLUS_OPERATION)(a, b)
     public override operator fun MST.unaryPlus(): MST.Unary =
-        unaryOperationFunction(SpaceOperations.PLUS_OPERATION)(this)
+        unaryOperationFunction(GroupOperations.PLUS_OPERATION)(this)
 
     public override operator fun MST.unaryMinus(): MST.Unary =
-        unaryOperationFunction(SpaceOperations.MINUS_OPERATION)(this)
+        unaryOperationFunction(GroupOperations.MINUS_OPERATION)(this)
 
     public override operator fun MST.minus(b: MST): MST.Binary =
-        binaryOperationFunction(SpaceOperations.MINUS_OPERATION)(this, b)
+        binaryOperationFunction(GroupOperations.MINUS_OPERATION)(this, b)
 
     public override fun scale(a: MST, value: Double): MST.Binary =
         binaryOperationFunction(RingOperations.TIMES_OPERATION)(a, number(value))
@@ -50,25 +50,25 @@ public object MstSpace : Space<MST>, NumericAlgebra<MST>, ScaleOperations<MST> {
  */
 @OptIn(UnstableKMathAPI::class)
 public object MstRing : Ring<MST>, NumbersAddOperations<MST>, ScaleOperations<MST> {
-    public override val zero: MST.Numeric = MstSpace.zero
+    public override val zero: MST.Numeric = MstGroup.zero
     public override val one: MST.Numeric = number(1.0)
 
-    public override fun number(value: Number): MST.Numeric = MstSpace.number(value)
-    public override fun bindSymbol(value: String): MST.Symbolic = MstSpace.bindSymbol(value)
-    public override fun add(a: MST, b: MST): MST.Binary = MstSpace.add(a, b)
+    public override fun number(value: Number): MST.Numeric = MstGroup.number(value)
+    public override fun bindSymbol(value: String): MST.Symbolic = MstGroup.bindSymbol(value)
+    public override fun add(a: MST, b: MST): MST.Binary = MstGroup.add(a, b)
 
     public override fun scale(a: MST, value: Double): MST.Binary =
-        MstSpace.binaryOperationFunction(RingOperations.TIMES_OPERATION)(a, MstSpace.number(value))
+        MstGroup.binaryOperationFunction(RingOperations.TIMES_OPERATION)(a, MstGroup.number(value))
 
     public override fun multiply(a: MST, b: MST): MST.Binary =
         binaryOperationFunction(RingOperations.TIMES_OPERATION)(a, b)
 
-    public override operator fun MST.unaryPlus(): MST.Unary = MstSpace { +this@unaryPlus }
-    public override operator fun MST.unaryMinus(): MST.Unary = MstSpace { -this@unaryMinus }
-    public override operator fun MST.minus(b: MST): MST.Binary = MstSpace { this@minus - b }
+    public override operator fun MST.unaryPlus(): MST.Unary = MstGroup { +this@unaryPlus }
+    public override operator fun MST.unaryMinus(): MST.Unary = MstGroup { -this@unaryMinus }
+    public override operator fun MST.minus(b: MST): MST.Binary = MstGroup { this@minus - b }
 
     public override fun binaryOperationFunction(operation: String): (left: MST, right: MST) -> MST.Binary =
-        MstSpace.binaryOperationFunction(operation)
+        MstGroup.binaryOperationFunction(operation)
 
     public override fun unaryOperationFunction(operation: String): (arg: MST) -> MST.Unary =
         MstAlgebra.unaryOperationFunction(operation)
@@ -88,7 +88,7 @@ public object MstField : Field<MST>, NumbersAddOperations<MST>, ScaleOperations<
     public override fun add(a: MST, b: MST): MST.Binary = MstRing.add(a, b)
 
     public override fun scale(a: MST, value: Double): MST.Binary =
-        MstSpace.binaryOperationFunction(RingOperations.TIMES_OPERATION)(a, MstSpace.number(value))
+        MstGroup.binaryOperationFunction(RingOperations.TIMES_OPERATION)(a, MstGroup.number(value))
 
     public override fun multiply(a: MST, b: MST): MST.Binary = MstRing.multiply(a, b)
     public override fun divide(a: MST, b: MST): MST.Binary =
@@ -129,7 +129,7 @@ public object MstExtendedField : ExtendedField<MST>, NumericAlgebra<MST> {
     public override fun add(a: MST, b: MST): MST.Binary = MstField.add(a, b)
 
     public override fun scale(a: MST, value: Double): MST =
-        binaryOperation(SpaceOperations.PLUS_OPERATION, a, number(value))
+        binaryOperation(GroupOperations.PLUS_OPERATION, a, number(value))
 
     public override fun multiply(a: MST, b: MST): MST.Binary = MstField.multiply(a, b)
     public override fun divide(a: MST, b: MST): MST.Binary = MstField.divide(a, b)
diff --git a/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/MstExpression.kt b/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/MstExpression.kt
index 412dde32c..3a598fb8c 100644
--- a/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/MstExpression.kt
+++ b/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/MstExpression.kt
@@ -54,13 +54,13 @@ public inline fun <reified T : Any, A : Algebra<T>, E : Algebra<MST>> A.mst(
 ): MstExpression<T, A> = MstExpression(this, mstAlgebra.block())
 
 /**
- * Builds [MstExpression] over [Space].
+ * Builds [MstExpression] over [Group].
  *
  * @author Alexander Nozik
  */
-public inline fun <reified T : Any, A : Space<T>> A.mstInSpace(block: MstSpace.() -> MST): MstExpression<T, A> {
+public inline fun <reified T : Any, A : Group<T>> A.mstInSpace(block: MstGroup.() -> MST): MstExpression<T, A> {
     contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) }
-    return MstExpression(this, MstSpace.block())
+    return MstExpression(this, MstGroup.block())
 }
 
 /**
@@ -94,11 +94,11 @@ public inline fun <reified T : Any, A : ExtendedField<T>> A.mstInExtendedField(b
 }
 
 /**
- * Builds [MstExpression] over [FunctionalExpressionSpace].
+ * Builds [MstExpression] over [FunctionalExpressionGroup].
  *
  * @author Alexander Nozik
  */
-public inline fun <reified T : Any, A : Space<T>> FunctionalExpressionSpace<T, A>.mstInSpace(block: MstSpace.() -> MST): MstExpression<T, A> {
+public inline fun <reified T : Any, A : Group<T>> FunctionalExpressionGroup<T, A>.mstInSpace(block: MstGroup.() -> MST): MstExpression<T, A> {
     contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) }
     return algebra.mstInSpace(block)
 }
diff --git a/kmath-ast/src/jsTest/kotlin/space/kscience/kmath/estree/TestESTreeConsistencyWithInterpreter.kt b/kmath-ast/src/jsTest/kotlin/space/kscience/kmath/estree/TestESTreeConsistencyWithInterpreter.kt
index c91cc4daf..34e9dd945 100644
--- a/kmath-ast/src/jsTest/kotlin/space/kscience/kmath/estree/TestESTreeConsistencyWithInterpreter.kt
+++ b/kmath-ast/src/jsTest/kotlin/space/kscience/kmath/estree/TestESTreeConsistencyWithInterpreter.kt
@@ -12,7 +12,7 @@ import kotlin.test.assertEquals
 internal class TestESTreeConsistencyWithInterpreter {
     @Test
     fun mstSpace() {
-        val res1 = MstSpace.mstInSpace {
+        val res1 = MstGroup.mstInSpace {
             binaryOperationFunction("+")(
                 unaryOperationFunction("+")(
                     number(3.toByte()) - (number(2.toByte()) + (scale(
@@ -25,7 +25,7 @@ internal class TestESTreeConsistencyWithInterpreter {
             ) + bindSymbol("x") + zero
         }("x" to MST.Numeric(2))
 
-        val res2 = MstSpace.mstInSpace {
+        val res2 = MstGroup.mstInSpace {
             binaryOperationFunction("+")(
                 unaryOperationFunction("+")(
                     number(3.toByte()) - (number(2.toByte()) + (scale(
diff --git a/kmath-ast/src/jvmMain/kotlin/space/kscience/kmath/ast/parser.kt b/kmath-ast/src/jvmMain/kotlin/space/kscience/kmath/ast/parser.kt
index be4aff34f..9a38ce81a 100644
--- a/kmath-ast/src/jvmMain/kotlin/space/kscience/kmath/ast/parser.kt
+++ b/kmath-ast/src/jvmMain/kotlin/space/kscience/kmath/ast/parser.kt
@@ -14,9 +14,9 @@ import com.github.h0tk3y.betterParse.lexer.regexToken
 import com.github.h0tk3y.betterParse.parser.ParseResult
 import com.github.h0tk3y.betterParse.parser.Parser
 import space.kscience.kmath.operations.FieldOperations
+import space.kscience.kmath.operations.GroupOperations
 import space.kscience.kmath.operations.PowerOperations
 import space.kscience.kmath.operations.RingOperations
-import space.kscience.kmath.operations.SpaceOperations
 
 /**
  * better-parse implementation of grammar defined in the ArithmeticsEvaluator.g4.
@@ -55,7 +55,7 @@ public object ArithmeticsEvaluator : Grammar<MST>() {
         .or(binaryFunction)
         .or(unaryFunction)
         .or(singular)
-        .or(-minus and parser(ArithmeticsEvaluator::term) map { MST.Unary(SpaceOperations.MINUS_OPERATION, it) })
+        .or(-minus and parser(ArithmeticsEvaluator::term) map { MST.Unary(GroupOperations.MINUS_OPERATION, it) })
         .or(-lpar and parser(ArithmeticsEvaluator::subSumChain) and -rpar)
 
     private val powChain: Parser<MST> by leftAssociative(term = term, operator = pow) { a, _, b ->
@@ -77,9 +77,9 @@ public object ArithmeticsEvaluator : Grammar<MST>() {
         operator = plus or minus use TokenMatch::type
     ) { a, op, b ->
         if (op == plus)
-            MST.Binary(SpaceOperations.PLUS_OPERATION, a, b)
+            MST.Binary(GroupOperations.PLUS_OPERATION, a, b)
         else
-            MST.Binary(SpaceOperations.MINUS_OPERATION, a, b)
+            MST.Binary(GroupOperations.MINUS_OPERATION, a, b)
     }
 
     override val rootParser: Parser<MST> by subSumChain
diff --git a/kmath-ast/src/jvmTest/kotlin/space/kscience/kmath/asm/TestAsmConsistencyWithInterpreter.kt b/kmath-ast/src/jvmTest/kotlin/space/kscience/kmath/asm/TestAsmConsistencyWithInterpreter.kt
index 5c6297f3f..4be2ee331 100644
--- a/kmath-ast/src/jvmTest/kotlin/space/kscience/kmath/asm/TestAsmConsistencyWithInterpreter.kt
+++ b/kmath-ast/src/jvmTest/kotlin/space/kscience/kmath/asm/TestAsmConsistencyWithInterpreter.kt
@@ -12,7 +12,7 @@ import kotlin.test.assertEquals
 internal class TestAsmConsistencyWithInterpreter {
     @Test
     fun mstSpace() {
-        val res1 = MstSpace.mstInSpace {
+        val res1 = MstGroup.mstInSpace {
             binaryOperationFunction("+")(
                 unaryOperationFunction("+")(
                     number(3.toByte()) - (number(2.toByte()) + (scale(
@@ -25,7 +25,7 @@ internal class TestAsmConsistencyWithInterpreter {
             ) + bindSymbol("x") + zero
         }("x" to MST.Numeric(2))
 
-        val res2 = MstSpace.mstInSpace {
+        val res2 = MstGroup.mstInSpace {
             binaryOperationFunction("+")(
                 unaryOperationFunction("+")(
                     number(3.toByte()) - (number(2.toByte()) + (scale(
diff --git a/kmath-core/api/kmath-core.api b/kmath-core/api/kmath-core.api
index da4725428..eae91c985 100644
--- a/kmath-core/api/kmath-core.api
+++ b/kmath-core/api/kmath-core.api
@@ -52,7 +52,7 @@ public final class space/kscience/kmath/expressions/ExpressionBuildersKt {
 	public static final fun extendedFieldExpression (Lspace/kscience/kmath/operations/ExtendedField;Lkotlin/jvm/functions/Function1;)Lspace/kscience/kmath/expressions/Expression;
 	public static final fun fieldExpression (Lspace/kscience/kmath/operations/Field;Lkotlin/jvm/functions/Function1;)Lspace/kscience/kmath/expressions/Expression;
 	public static final fun ringExpression (Lspace/kscience/kmath/operations/Ring;Lkotlin/jvm/functions/Function1;)Lspace/kscience/kmath/expressions/Expression;
-	public static final fun spaceExpression (Lspace/kscience/kmath/operations/Space;Lkotlin/jvm/functions/Function1;)Lspace/kscience/kmath/expressions/Expression;
+	public static final fun spaceExpression (Lspace/kscience/kmath/operations/Group;Lkotlin/jvm/functions/Function1;)Lspace/kscience/kmath/expressions/Expression;
 }
 
 public final class space/kscience/kmath/expressions/ExpressionKt {
@@ -91,7 +91,7 @@ public final class space/kscience/kmath/expressions/FunctionalExpressionAlgebraK
 	public static final fun expressionInExtendedField (Lspace/kscience/kmath/operations/ExtendedField;Lkotlin/jvm/functions/Function1;)Lspace/kscience/kmath/expressions/Expression;
 	public static final fun expressionInField (Lspace/kscience/kmath/operations/Field;Lkotlin/jvm/functions/Function1;)Lspace/kscience/kmath/expressions/Expression;
 	public static final fun expressionInRing (Lspace/kscience/kmath/operations/Ring;Lkotlin/jvm/functions/Function1;)Lspace/kscience/kmath/expressions/Expression;
-	public static final fun expressionInSpace (Lspace/kscience/kmath/operations/Space;Lkotlin/jvm/functions/Function1;)Lspace/kscience/kmath/expressions/Expression;
+	public static final fun expressionInSpace (Lspace/kscience/kmath/operations/Group;Lkotlin/jvm/functions/Function1;)Lspace/kscience/kmath/expressions/Expression;
 }
 
 public class space/kscience/kmath/expressions/FunctionalExpressionExtendedField : space/kscience/kmath/expressions/FunctionalExpressionField, space/kscience/kmath/operations/ExtendedField {
@@ -165,22 +165,8 @@ public class space/kscience/kmath/expressions/FunctionalExpressionField : space/
 	public fun unaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
 }
 
-public class space/kscience/kmath/expressions/FunctionalExpressionRing : space/kscience/kmath/expressions/FunctionalExpressionSpace, space/kscience/kmath/operations/Ring {
-	public fun <init> (Lspace/kscience/kmath/operations/Ring;)V
-	public fun binaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
-	public synthetic fun getOne ()Ljava/lang/Object;
-	public fun getOne ()Lspace/kscience/kmath/expressions/Expression;
-	public synthetic fun multiply (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun multiply (Lspace/kscience/kmath/expressions/Expression;Lspace/kscience/kmath/expressions/Expression;)Lspace/kscience/kmath/expressions/Expression;
-	public synthetic fun times (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public final fun times (Ljava/lang/Object;Lspace/kscience/kmath/expressions/Expression;)Lspace/kscience/kmath/expressions/Expression;
-	public final fun times (Lspace/kscience/kmath/expressions/Expression;Ljava/lang/Object;)Lspace/kscience/kmath/expressions/Expression;
-	public fun times (Lspace/kscience/kmath/expressions/Expression;Lspace/kscience/kmath/expressions/Expression;)Lspace/kscience/kmath/expressions/Expression;
-	public fun unaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
-}
-
-public class space/kscience/kmath/expressions/FunctionalExpressionSpace : space/kscience/kmath/expressions/FunctionalExpressionAlgebra, space/kscience/kmath/operations/Space {
-	public fun <init> (Lspace/kscience/kmath/operations/Space;)V
+public class space/kscience/kmath/expressions/FunctionalExpressionGroup : space/kscience/kmath/expressions/FunctionalExpressionAlgebra, space/kscience/kmath/operations/Group {
+	public fun <init> (Lspace/kscience/kmath/operations/Group;)V
 	public synthetic fun add (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun add (Lspace/kscience/kmath/expressions/Expression;Lspace/kscience/kmath/expressions/Expression;)Lspace/kscience/kmath/expressions/Expression;
 	public fun binaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
@@ -201,6 +187,20 @@ public class space/kscience/kmath/expressions/FunctionalExpressionSpace : space/
 	public fun unaryPlus (Lspace/kscience/kmath/expressions/Expression;)Lspace/kscience/kmath/expressions/Expression;
 }
 
+public class space/kscience/kmath/expressions/FunctionalExpressionRing : space/kscience/kmath/expressions/FunctionalExpressionGroup, space/kscience/kmath/operations/Ring {
+	public fun <init> (Lspace/kscience/kmath/operations/Ring;)V
+	public fun binaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
+	public synthetic fun getOne ()Ljava/lang/Object;
+	public fun getOne ()Lspace/kscience/kmath/expressions/Expression;
+	public synthetic fun multiply (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+	public fun multiply (Lspace/kscience/kmath/expressions/Expression;Lspace/kscience/kmath/expressions/Expression;)Lspace/kscience/kmath/expressions/Expression;
+	public synthetic fun times (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+	public final fun times (Ljava/lang/Object;Lspace/kscience/kmath/expressions/Expression;)Lspace/kscience/kmath/expressions/Expression;
+	public final fun times (Lspace/kscience/kmath/expressions/Expression;Ljava/lang/Object;)Lspace/kscience/kmath/expressions/Expression;
+	public fun times (Lspace/kscience/kmath/expressions/Expression;Lspace/kscience/kmath/expressions/Expression;)Lspace/kscience/kmath/expressions/Expression;
+	public fun unaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
+}
+
 public final class space/kscience/kmath/expressions/SimpleAutoDiffExpression : space/kscience/kmath/expressions/FirstDerivativeExpression {
 	public fun <init> (Lspace/kscience/kmath/operations/Field;Lkotlin/jvm/functions/Function1;)V
 	public fun derivativeOrNull (Lspace/kscience/kmath/expressions/Symbol;)Lspace/kscience/kmath/expressions/Expression;
@@ -490,7 +490,7 @@ public final class space/kscience/kmath/linear/BufferMatrixContext : space/kscie
 public final class space/kscience/kmath/linear/BufferMatrixContext$Companion {
 }
 
-public final class space/kscience/kmath/linear/BufferVectorSpace : space/kscience/kmath/linear/VectorSpace {
+public final class space/kscience/kmath/linear/BufferVectorGroup : space/kscience/kmath/linear/VectorSpace {
 	public fun <init> (ILspace/kscience/kmath/operations/Ring;Lkotlin/jvm/functions/Function2;)V
 	public synthetic fun add (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun add (Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
@@ -625,7 +625,7 @@ public final class space/kscience/kmath/linear/MatrixBuilderKt {
 	public static final fun row (Lspace/kscience/kmath/nd/Structure2D$Companion;[Ljava/lang/Object;)Lspace/kscience/kmath/nd/Structure2D;
 }
 
-public abstract interface class space/kscience/kmath/linear/MatrixContext : space/kscience/kmath/operations/SpaceOperations {
+public abstract interface class space/kscience/kmath/linear/MatrixContext : space/kscience/kmath/operations/GroupOperations {
 	public static final field Companion Lspace/kscience/kmath/linear/MatrixContext$Companion;
 	public abstract fun binaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public abstract fun dot (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
@@ -763,7 +763,7 @@ public final class space/kscience/kmath/linear/UnitFeature : space/kscience/kmat
 	public static final field INSTANCE Lspace/kscience/kmath/linear/UnitFeature;
 }
 
-public abstract interface class space/kscience/kmath/linear/VectorSpace : space/kscience/kmath/operations/Space {
+public abstract interface class space/kscience/kmath/linear/VectorSpace : space/kscience/kmath/operations/Group {
 	public static final field Companion Lspace/kscience/kmath/linear/VectorSpace$Companion;
 	public abstract fun add (Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
 	public abstract fun getAlgebra ()Lspace/kscience/kmath/operations/Ring;
@@ -775,9 +775,9 @@ public abstract interface class space/kscience/kmath/linear/VectorSpace : space/
 }
 
 public final class space/kscience/kmath/linear/VectorSpace$Companion {
-	public final fun buffered (ILspace/kscience/kmath/operations/Ring;Lkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/linear/BufferVectorSpace;
-	public static synthetic fun buffered$default (Lspace/kscience/kmath/linear/VectorSpace$Companion;ILspace/kscience/kmath/operations/Ring;Lkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lspace/kscience/kmath/linear/BufferVectorSpace;
-	public final fun real (I)Lspace/kscience/kmath/linear/BufferVectorSpace;
+	public final fun buffered (ILspace/kscience/kmath/operations/Ring;Lkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/linear/BufferVectorGroup;
+	public static synthetic fun buffered$default (Lspace/kscience/kmath/linear/VectorSpace$Companion;ILspace/kscience/kmath/operations/Ring;Lkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lspace/kscience/kmath/linear/BufferVectorGroup;
+	public final fun real (I)Lspace/kscience/kmath/linear/BufferVectorGroup;
 }
 
 public final class space/kscience/kmath/linear/VectorSpace$DefaultImpls {
@@ -820,9 +820,9 @@ public final class space/kscience/kmath/misc/CumulativeKt {
 	public static final fun cumulative (Ljava/util/Iterator;Ljava/lang/Object;Lkotlin/jvm/functions/Function2;)Ljava/util/Iterator;
 	public static final fun cumulative (Ljava/util/List;Ljava/lang/Object;Lkotlin/jvm/functions/Function2;)Ljava/util/List;
 	public static final fun cumulative (Lkotlin/sequences/Sequence;Ljava/lang/Object;Lkotlin/jvm/functions/Function2;)Lkotlin/sequences/Sequence;
-	public static final fun cumulativeSum (Ljava/lang/Iterable;Lspace/kscience/kmath/operations/Space;)Ljava/lang/Iterable;
-	public static final fun cumulativeSum (Ljava/util/List;Lspace/kscience/kmath/operations/Space;)Ljava/util/List;
-	public static final fun cumulativeSum (Lkotlin/sequences/Sequence;Lspace/kscience/kmath/operations/Space;)Lkotlin/sequences/Sequence;
+	public static final fun cumulativeSum (Ljava/lang/Iterable;Lspace/kscience/kmath/operations/Group;)Ljava/lang/Iterable;
+	public static final fun cumulativeSum (Ljava/util/List;Lspace/kscience/kmath/operations/Group;)Ljava/util/List;
+	public static final fun cumulativeSum (Lkotlin/sequences/Sequence;Lspace/kscience/kmath/operations/Group;)Lkotlin/sequences/Sequence;
 	public static final fun cumulativeSumOfDouble (Ljava/lang/Iterable;)Ljava/lang/Iterable;
 	public static final fun cumulativeSumOfDouble (Ljava/util/List;)Ljava/util/List;
 	public static final fun cumulativeSumOfDouble (Lkotlin/sequences/Sequence;)Lkotlin/sequences/Sequence;
@@ -860,9 +860,9 @@ public final class space/kscience/kmath/nd/BufferNDAlgebraKt {
 	public static final fun field (Lspace/kscience/kmath/nd/NDAlgebra$Companion;Lspace/kscience/kmath/operations/Field;Lkotlin/jvm/functions/Function2;[I)Lspace/kscience/kmath/nd/BufferedNDField;
 	public static final fun ndField (Lspace/kscience/kmath/operations/Field;Lkotlin/jvm/functions/Function2;[ILkotlin/jvm/functions/Function1;)Ljava/lang/Object;
 	public static final fun ndRing (Lspace/kscience/kmath/operations/Ring;Lkotlin/jvm/functions/Function2;[ILkotlin/jvm/functions/Function1;)Ljava/lang/Object;
-	public static final fun ndSpace (Lspace/kscience/kmath/operations/Space;Lkotlin/jvm/functions/Function2;[ILkotlin/jvm/functions/Function1;)Ljava/lang/Object;
+	public static final fun ndSpace (Lspace/kscience/kmath/operations/Group;Lkotlin/jvm/functions/Function2;[ILkotlin/jvm/functions/Function1;)Ljava/lang/Object;
 	public static final fun ring (Lspace/kscience/kmath/nd/NDAlgebra$Companion;Lspace/kscience/kmath/operations/Ring;Lkotlin/jvm/functions/Function2;[I)Lspace/kscience/kmath/nd/BufferedNDRing;
-	public static final fun space (Lspace/kscience/kmath/nd/NDAlgebra$Companion;Lspace/kscience/kmath/operations/Space;Lkotlin/jvm/functions/Function2;[I)Lspace/kscience/kmath/nd/BufferedNDSpace;
+	public static final fun space (Lspace/kscience/kmath/nd/NDAlgebra$Companion;Lspace/kscience/kmath/operations/Group;Lkotlin/jvm/functions/Function2;[I)Lspace/kscience/kmath/nd/BufferedNDGroup;
 }
 
 public class space/kscience/kmath/nd/BufferedNDField : space/kscience/kmath/nd/BufferedNDRing, space/kscience/kmath/nd/NDField {
@@ -892,21 +892,8 @@ public class space/kscience/kmath/nd/BufferedNDField : space/kscience/kmath/nd/B
 	public fun times (Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Number;)Lspace/kscience/kmath/nd/NDStructure;
 }
 
-public class space/kscience/kmath/nd/BufferedNDRing : space/kscience/kmath/nd/BufferedNDSpace, space/kscience/kmath/nd/NDRing {
-	public fun <init> ([ILspace/kscience/kmath/operations/Ring;Lkotlin/jvm/functions/Function2;)V
-	public fun binaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
-	public synthetic fun getOne ()Ljava/lang/Object;
-	public fun getOne ()Lspace/kscience/kmath/nd/NDBuffer;
-	public synthetic fun multiply (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun multiply (Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
-	public synthetic fun times (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun times (Ljava/lang/Object;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
-	public fun times (Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Object;)Lspace/kscience/kmath/nd/NDStructure;
-	public fun times (Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
-}
-
-public class space/kscience/kmath/nd/BufferedNDSpace : space/kscience/kmath/nd/BufferNDAlgebra, space/kscience/kmath/nd/NDSpace {
-	public fun <init> ([ILspace/kscience/kmath/operations/Space;Lkotlin/jvm/functions/Function2;)V
+public class space/kscience/kmath/nd/BufferedNDGroup : space/kscience/kmath/nd/BufferNDAlgebra, space/kscience/kmath/nd/NDGroup {
+	public fun <init> ([ILspace/kscience/kmath/operations/Group;Lkotlin/jvm/functions/Function2;)V
 	public synthetic fun add (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun add (Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 	public synthetic fun binaryOperation (Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
@@ -919,7 +906,7 @@ public class space/kscience/kmath/nd/BufferedNDSpace : space/kscience/kmath/nd/B
 	public fun getBuffer (Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/structures/Buffer;
 	public final fun getBufferFactory ()Lkotlin/jvm/functions/Function2;
 	public synthetic fun getElementContext ()Lspace/kscience/kmath/operations/Algebra;
-	public final fun getElementContext ()Lspace/kscience/kmath/operations/Space;
+	public final fun getElementContext ()Lspace/kscience/kmath/operations/Group;
 	public final fun getShape ()[I
 	public fun getStrides ()Lspace/kscience/kmath/nd/Strides;
 	public synthetic fun getZero ()Ljava/lang/Object;
@@ -948,6 +935,19 @@ public class space/kscience/kmath/nd/BufferedNDSpace : space/kscience/kmath/nd/B
 	public fun unaryPlus (Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 }
 
+public class space/kscience/kmath/nd/BufferedNDRing : space/kscience/kmath/nd/BufferedNDGroup, space/kscience/kmath/nd/NDRing {
+	public fun <init> ([ILspace/kscience/kmath/operations/Ring;Lkotlin/jvm/functions/Function2;)V
+	public fun binaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
+	public synthetic fun getOne ()Ljava/lang/Object;
+	public fun getOne ()Lspace/kscience/kmath/nd/NDBuffer;
+	public synthetic fun multiply (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+	public fun multiply (Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
+	public synthetic fun times (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+	public fun times (Ljava/lang/Object;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
+	public fun times (Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Object;)Lspace/kscience/kmath/nd/NDStructure;
+	public fun times (Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
+}
+
 public final class space/kscience/kmath/nd/DefaultStrides : space/kscience/kmath/nd/Strides {
 	public static final field Companion Lspace/kscience/kmath/nd/DefaultStrides$Companion;
 	public synthetic fun <init> ([ILkotlin/jvm/internal/DefaultConstructorMarker;)V
@@ -1050,7 +1050,36 @@ public final class space/kscience/kmath/nd/NDField$DefaultImpls {
 	public static fun unaryPlus (Lspace/kscience/kmath/nd/NDField;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 }
 
-public abstract interface class space/kscience/kmath/nd/NDRing : space/kscience/kmath/nd/NDSpace, space/kscience/kmath/operations/Ring {
+public abstract interface class space/kscience/kmath/nd/NDGroup : space/kscience/kmath/nd/NDAlgebra, space/kscience/kmath/operations/Group {
+	public static final field Companion Lspace/kscience/kmath/nd/NDGroup$Companion;
+	public abstract fun add (Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
+	public abstract fun minus (Ljava/lang/Object;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
+	public abstract fun minus (Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Object;)Lspace/kscience/kmath/nd/NDStructure;
+	public abstract fun plus (Ljava/lang/Object;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
+	public abstract fun plus (Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Object;)Lspace/kscience/kmath/nd/NDStructure;
+}
+
+public final class space/kscience/kmath/nd/NDGroup$Companion {
+}
+
+public final class space/kscience/kmath/nd/NDGroup$DefaultImpls {
+	public static fun add (Lspace/kscience/kmath/nd/NDGroup;Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
+	public static fun binaryOperation (Lspace/kscience/kmath/nd/NDGroup;Ljava/lang/String;Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
+	public static fun binaryOperationFunction (Lspace/kscience/kmath/nd/NDGroup;Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
+	public static fun bindSymbol (Lspace/kscience/kmath/nd/NDGroup;Ljava/lang/String;)Lspace/kscience/kmath/nd/NDStructure;
+	public static fun invoke (Lspace/kscience/kmath/nd/NDGroup;Lkotlin/jvm/functions/Function1;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
+	public static fun minus (Lspace/kscience/kmath/nd/NDGroup;Ljava/lang/Object;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
+	public static fun minus (Lspace/kscience/kmath/nd/NDGroup;Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Object;)Lspace/kscience/kmath/nd/NDStructure;
+	public static fun minus (Lspace/kscience/kmath/nd/NDGroup;Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
+	public static fun plus (Lspace/kscience/kmath/nd/NDGroup;Ljava/lang/Object;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
+	public static fun plus (Lspace/kscience/kmath/nd/NDGroup;Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Object;)Lspace/kscience/kmath/nd/NDStructure;
+	public static fun plus (Lspace/kscience/kmath/nd/NDGroup;Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
+	public static fun unaryOperation (Lspace/kscience/kmath/nd/NDGroup;Ljava/lang/String;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
+	public static fun unaryOperationFunction (Lspace/kscience/kmath/nd/NDGroup;Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
+	public static fun unaryPlus (Lspace/kscience/kmath/nd/NDGroup;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
+}
+
+public abstract interface class space/kscience/kmath/nd/NDRing : space/kscience/kmath/nd/NDGroup, space/kscience/kmath/operations/Ring {
 	public static final field Companion Lspace/kscience/kmath/nd/NDRing$Companion;
 	public abstract fun multiply (Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 	public abstract fun times (Ljava/lang/Object;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
@@ -1081,35 +1110,6 @@ public final class space/kscience/kmath/nd/NDRing$DefaultImpls {
 	public static fun unaryPlus (Lspace/kscience/kmath/nd/NDRing;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
 }
 
-public abstract interface class space/kscience/kmath/nd/NDSpace : space/kscience/kmath/nd/NDAlgebra, space/kscience/kmath/operations/Space {
-	public static final field Companion Lspace/kscience/kmath/nd/NDSpace$Companion;
-	public abstract fun add (Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
-	public abstract fun minus (Ljava/lang/Object;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
-	public abstract fun minus (Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Object;)Lspace/kscience/kmath/nd/NDStructure;
-	public abstract fun plus (Ljava/lang/Object;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
-	public abstract fun plus (Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Object;)Lspace/kscience/kmath/nd/NDStructure;
-}
-
-public final class space/kscience/kmath/nd/NDSpace$Companion {
-}
-
-public final class space/kscience/kmath/nd/NDSpace$DefaultImpls {
-	public static fun add (Lspace/kscience/kmath/nd/NDSpace;Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
-	public static fun binaryOperation (Lspace/kscience/kmath/nd/NDSpace;Ljava/lang/String;Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
-	public static fun binaryOperationFunction (Lspace/kscience/kmath/nd/NDSpace;Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
-	public static fun bindSymbol (Lspace/kscience/kmath/nd/NDSpace;Ljava/lang/String;)Lspace/kscience/kmath/nd/NDStructure;
-	public static fun invoke (Lspace/kscience/kmath/nd/NDSpace;Lkotlin/jvm/functions/Function1;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
-	public static fun minus (Lspace/kscience/kmath/nd/NDSpace;Ljava/lang/Object;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
-	public static fun minus (Lspace/kscience/kmath/nd/NDSpace;Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Object;)Lspace/kscience/kmath/nd/NDStructure;
-	public static fun minus (Lspace/kscience/kmath/nd/NDSpace;Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
-	public static fun plus (Lspace/kscience/kmath/nd/NDSpace;Ljava/lang/Object;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
-	public static fun plus (Lspace/kscience/kmath/nd/NDSpace;Lspace/kscience/kmath/nd/NDStructure;Ljava/lang/Object;)Lspace/kscience/kmath/nd/NDStructure;
-	public static fun plus (Lspace/kscience/kmath/nd/NDSpace;Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
-	public static fun unaryOperation (Lspace/kscience/kmath/nd/NDSpace;Ljava/lang/String;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
-	public static fun unaryOperationFunction (Lspace/kscience/kmath/nd/NDSpace;Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
-	public static fun unaryPlus (Lspace/kscience/kmath/nd/NDSpace;Lspace/kscience/kmath/nd/NDStructure;)Lspace/kscience/kmath/nd/NDStructure;
-}
-
 public abstract interface class space/kscience/kmath/nd/NDStructure {
 	public static final field Companion Lspace/kscience/kmath/nd/NDStructure$Companion;
 	public abstract fun elements ()Lkotlin/sequences/Sequence;
@@ -1333,17 +1333,17 @@ public final class space/kscience/kmath/operations/AlgebraElementsKt {
 }
 
 public final class space/kscience/kmath/operations/AlgebraExtensionsKt {
-	public static final fun abs (Lspace/kscience/kmath/operations/Space;Ljava/lang/Comparable;)Ljava/lang/Comparable;
-	public static final fun average (Lspace/kscience/kmath/operations/Space;Ljava/lang/Iterable;)Ljava/lang/Object;
-	public static final fun average (Lspace/kscience/kmath/operations/Space;Lkotlin/sequences/Sequence;)Ljava/lang/Object;
-	public static final fun averageWith (Ljava/lang/Iterable;Lspace/kscience/kmath/operations/Space;)Ljava/lang/Object;
-	public static final fun averageWith (Lkotlin/sequences/Sequence;Lspace/kscience/kmath/operations/Space;)Ljava/lang/Object;
+	public static final fun abs (Lspace/kscience/kmath/operations/Group;Ljava/lang/Comparable;)Ljava/lang/Comparable;
+	public static final fun average (Lspace/kscience/kmath/operations/Group;Ljava/lang/Iterable;)Ljava/lang/Object;
+	public static final fun average (Lspace/kscience/kmath/operations/Group;Lkotlin/sequences/Sequence;)Ljava/lang/Object;
+	public static final fun averageWith (Ljava/lang/Iterable;Lspace/kscience/kmath/operations/Group;)Ljava/lang/Object;
+	public static final fun averageWith (Lkotlin/sequences/Sequence;Lspace/kscience/kmath/operations/Group;)Ljava/lang/Object;
 	public static final fun power (Lspace/kscience/kmath/operations/Field;Ljava/lang/Object;I)Ljava/lang/Object;
 	public static final fun power (Lspace/kscience/kmath/operations/Ring;Ljava/lang/Object;I)Ljava/lang/Object;
-	public static final fun sum (Lspace/kscience/kmath/operations/Space;Ljava/lang/Iterable;)Ljava/lang/Object;
-	public static final fun sum (Lspace/kscience/kmath/operations/Space;Lkotlin/sequences/Sequence;)Ljava/lang/Object;
-	public static final fun sumWith (Ljava/lang/Iterable;Lspace/kscience/kmath/operations/Space;)Ljava/lang/Object;
-	public static final fun sumWith (Lkotlin/sequences/Sequence;Lspace/kscience/kmath/operations/Space;)Ljava/lang/Object;
+	public static final fun sum (Lspace/kscience/kmath/operations/Group;Ljava/lang/Iterable;)Ljava/lang/Object;
+	public static final fun sum (Lspace/kscience/kmath/operations/Group;Lkotlin/sequences/Sequence;)Ljava/lang/Object;
+	public static final fun sumWith (Ljava/lang/Iterable;Lspace/kscience/kmath/operations/Group;)Ljava/lang/Object;
+	public static final fun sumWith (Lkotlin/sequences/Sequence;Lspace/kscience/kmath/operations/Group;)Ljava/lang/Object;
 }
 
 public final class space/kscience/kmath/operations/AlgebraKt {
@@ -1735,6 +1735,50 @@ public final class space/kscience/kmath/operations/FloatField : space/kscience/k
 	public synthetic fun unaryPlus (Ljava/lang/Object;)Ljava/lang/Object;
 }
 
+public abstract interface class space/kscience/kmath/operations/Group : space/kscience/kmath/operations/GroupOperations {
+	public abstract fun getZero ()Ljava/lang/Object;
+}
+
+public final class space/kscience/kmath/operations/Group$DefaultImpls {
+	public static fun binaryOperation (Lspace/kscience/kmath/operations/Group;Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+	public static fun binaryOperationFunction (Lspace/kscience/kmath/operations/Group;Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
+	public static fun bindSymbol (Lspace/kscience/kmath/operations/Group;Ljava/lang/String;)Ljava/lang/Object;
+	public static fun minus (Lspace/kscience/kmath/operations/Group;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+	public static fun plus (Lspace/kscience/kmath/operations/Group;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+	public static fun unaryOperation (Lspace/kscience/kmath/operations/Group;Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/Object;
+	public static fun unaryOperationFunction (Lspace/kscience/kmath/operations/Group;Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
+	public static fun unaryPlus (Lspace/kscience/kmath/operations/Group;Ljava/lang/Object;)Ljava/lang/Object;
+}
+
+public abstract interface class space/kscience/kmath/operations/GroupOperations : space/kscience/kmath/operations/Algebra {
+	public static final field Companion Lspace/kscience/kmath/operations/GroupOperations$Companion;
+	public static final field MINUS_OPERATION Ljava/lang/String;
+	public static final field PLUS_OPERATION Ljava/lang/String;
+	public abstract fun add (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+	public abstract fun binaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
+	public abstract fun minus (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+	public abstract fun plus (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+	public abstract fun unaryMinus (Ljava/lang/Object;)Ljava/lang/Object;
+	public abstract fun unaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
+	public abstract fun unaryPlus (Ljava/lang/Object;)Ljava/lang/Object;
+}
+
+public final class space/kscience/kmath/operations/GroupOperations$Companion {
+	public static final field MINUS_OPERATION Ljava/lang/String;
+	public static final field PLUS_OPERATION Ljava/lang/String;
+}
+
+public final class space/kscience/kmath/operations/GroupOperations$DefaultImpls {
+	public static fun binaryOperation (Lspace/kscience/kmath/operations/GroupOperations;Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+	public static fun binaryOperationFunction (Lspace/kscience/kmath/operations/GroupOperations;Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
+	public static fun bindSymbol (Lspace/kscience/kmath/operations/GroupOperations;Ljava/lang/String;)Ljava/lang/Object;
+	public static fun minus (Lspace/kscience/kmath/operations/GroupOperations;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+	public static fun plus (Lspace/kscience/kmath/operations/GroupOperations;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+	public static fun unaryOperation (Lspace/kscience/kmath/operations/GroupOperations;Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/Object;
+	public static fun unaryOperationFunction (Lspace/kscience/kmath/operations/GroupOperations;Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
+	public static fun unaryPlus (Lspace/kscience/kmath/operations/GroupOperations;Ljava/lang/Object;)Ljava/lang/Object;
+}
+
 public final class space/kscience/kmath/operations/IntRing : space/kscience/kmath/operations/Norm, space/kscience/kmath/operations/NumericAlgebra, space/kscience/kmath/operations/Ring {
 	public static final field INSTANCE Lspace/kscience/kmath/operations/IntRing;
 	public fun add (II)Ljava/lang/Integer;
@@ -2078,7 +2122,7 @@ public final class space/kscience/kmath/operations/RealField : space/kscience/km
 	public synthetic fun unaryPlus (Ljava/lang/Object;)Ljava/lang/Object;
 }
 
-public abstract interface class space/kscience/kmath/operations/Ring : space/kscience/kmath/operations/RingOperations, space/kscience/kmath/operations/Space {
+public abstract interface class space/kscience/kmath/operations/Ring : space/kscience/kmath/operations/Group, space/kscience/kmath/operations/RingOperations {
 	public abstract fun getOne ()Ljava/lang/Object;
 }
 
@@ -2094,7 +2138,7 @@ public final class space/kscience/kmath/operations/Ring$DefaultImpls {
 	public static fun unaryPlus (Lspace/kscience/kmath/operations/Ring;Ljava/lang/Object;)Ljava/lang/Object;
 }
 
-public abstract interface class space/kscience/kmath/operations/RingOperations : space/kscience/kmath/operations/SpaceOperations {
+public abstract interface class space/kscience/kmath/operations/RingOperations : space/kscience/kmath/operations/GroupOperations {
 	public static final field Companion Lspace/kscience/kmath/operations/RingOperations$Companion;
 	public static final field TIMES_OPERATION Ljava/lang/String;
 	public abstract fun binaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
@@ -2176,50 +2220,6 @@ public final class space/kscience/kmath/operations/ShortRing : space/kscience/km
 	public fun unaryPlus (S)Ljava/lang/Short;
 }
 
-public abstract interface class space/kscience/kmath/operations/Space : space/kscience/kmath/operations/SpaceOperations {
-	public abstract fun getZero ()Ljava/lang/Object;
-}
-
-public final class space/kscience/kmath/operations/Space$DefaultImpls {
-	public static fun binaryOperation (Lspace/kscience/kmath/operations/Space;Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public static fun binaryOperationFunction (Lspace/kscience/kmath/operations/Space;Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
-	public static fun bindSymbol (Lspace/kscience/kmath/operations/Space;Ljava/lang/String;)Ljava/lang/Object;
-	public static fun minus (Lspace/kscience/kmath/operations/Space;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public static fun plus (Lspace/kscience/kmath/operations/Space;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public static fun unaryOperation (Lspace/kscience/kmath/operations/Space;Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/Object;
-	public static fun unaryOperationFunction (Lspace/kscience/kmath/operations/Space;Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
-	public static fun unaryPlus (Lspace/kscience/kmath/operations/Space;Ljava/lang/Object;)Ljava/lang/Object;
-}
-
-public abstract interface class space/kscience/kmath/operations/SpaceOperations : space/kscience/kmath/operations/Algebra {
-	public static final field Companion Lspace/kscience/kmath/operations/SpaceOperations$Companion;
-	public static final field MINUS_OPERATION Ljava/lang/String;
-	public static final field PLUS_OPERATION Ljava/lang/String;
-	public abstract fun add (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public abstract fun binaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
-	public abstract fun minus (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public abstract fun plus (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public abstract fun unaryMinus (Ljava/lang/Object;)Ljava/lang/Object;
-	public abstract fun unaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
-	public abstract fun unaryPlus (Ljava/lang/Object;)Ljava/lang/Object;
-}
-
-public final class space/kscience/kmath/operations/SpaceOperations$Companion {
-	public static final field MINUS_OPERATION Ljava/lang/String;
-	public static final field PLUS_OPERATION Ljava/lang/String;
-}
-
-public final class space/kscience/kmath/operations/SpaceOperations$DefaultImpls {
-	public static fun binaryOperation (Lspace/kscience/kmath/operations/SpaceOperations;Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public static fun binaryOperationFunction (Lspace/kscience/kmath/operations/SpaceOperations;Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
-	public static fun bindSymbol (Lspace/kscience/kmath/operations/SpaceOperations;Ljava/lang/String;)Ljava/lang/Object;
-	public static fun minus (Lspace/kscience/kmath/operations/SpaceOperations;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public static fun plus (Lspace/kscience/kmath/operations/SpaceOperations;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public static fun unaryOperation (Lspace/kscience/kmath/operations/SpaceOperations;Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/Object;
-	public static fun unaryOperationFunction (Lspace/kscience/kmath/operations/SpaceOperations;Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
-	public static fun unaryPlus (Lspace/kscience/kmath/operations/SpaceOperations;Ljava/lang/Object;)Ljava/lang/Object;
-}
-
 public abstract interface class space/kscience/kmath/operations/TrigonometricOperations : space/kscience/kmath/operations/Algebra {
 	public static final field ACOS_OPERATION Ljava/lang/String;
 	public static final field ASIN_OPERATION Ljava/lang/String;
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/FunctionalExpressionAlgebra.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/FunctionalExpressionAlgebra.kt
index 3c23d0ecf..880f13a3e 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/FunctionalExpressionAlgebra.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/FunctionalExpressionAlgebra.kt
@@ -41,21 +41,21 @@ public abstract class FunctionalExpressionAlgebra<T, A : Algebra<T>>(
 }
 
 /**
- * A context class for [Expression] construction for [Space] algebras.
+ * A context class for [Expression] construction for [Group] algebras.
  */
-public open class FunctionalExpressionSpace<T, A : Space<T>>(
+public open class FunctionalExpressionGroup<T, A : Group<T>>(
     algebra: A,
-) : FunctionalExpressionAlgebra<T, A>(algebra), Space<Expression<T>> {
+) : FunctionalExpressionAlgebra<T, A>(algebra), Group<Expression<T>> {
     public override val zero: Expression<T> get() = const(algebra.zero)
 
     override fun Expression<T>.unaryMinus(): Expression<T> =
-        unaryOperation(SpaceOperations.MINUS_OPERATION, this)
+        unaryOperation(GroupOperations.MINUS_OPERATION, this)
 
     /**
      * Builds an Expression of addition of two another expressions.
      */
     public override fun add(a: Expression<T>, b: Expression<T>): Expression<T> =
-        binaryOperation(SpaceOperations.PLUS_OPERATION, a, b)
+        binaryOperation(GroupOperations.PLUS_OPERATION, a, b)
 
 //    /**
 //     * Builds an Expression of multiplication of expression by number.
@@ -79,7 +79,7 @@ public open class FunctionalExpressionSpace<T, A : Space<T>>(
 
 public open class FunctionalExpressionRing<T, A : Ring<T>>(
     algebra: A,
-) : FunctionalExpressionSpace<T, A>(algebra), Ring<Expression<T>> {
+) : FunctionalExpressionGroup<T, A>(algebra), Ring<Expression<T>> {
     public override val one: Expression<T> get() = const(algebra.one)
 
     /**
@@ -92,10 +92,10 @@ public open class FunctionalExpressionRing<T, A : Ring<T>>(
     public operator fun T.times(arg: Expression<T>): Expression<T> = arg * this
 
     public override fun unaryOperationFunction(operation: String): (arg: Expression<T>) -> Expression<T> =
-        super<FunctionalExpressionSpace>.unaryOperationFunction(operation)
+        super<FunctionalExpressionGroup>.unaryOperationFunction(operation)
 
     public override fun binaryOperationFunction(operation: String): (left: Expression<T>, right: Expression<T>) -> Expression<T> =
-        super<FunctionalExpressionSpace>.binaryOperationFunction(operation)
+        super<FunctionalExpressionGroup>.binaryOperationFunction(operation)
 }
 
 public open class FunctionalExpressionField<T, A:  Field<T>>(
@@ -159,8 +159,8 @@ public open class FunctionalExpressionExtendedField<T, A : ExtendedField<T>>(
         super<FunctionalExpressionField>.binaryOperationFunction(operation)
 }
 
-public inline fun <T, A : Space<T>> A.expressionInSpace(block: FunctionalExpressionSpace<T, A>.() -> Expression<T>): Expression<T> =
-    FunctionalExpressionSpace(this).block()
+public inline fun <T, A : Group<T>> A.expressionInSpace(block: FunctionalExpressionGroup<T, A>.() -> Expression<T>): Expression<T> =
+    FunctionalExpressionGroup(this).block()
 
 public inline fun <T, A : Ring<T>> A.expressionInRing(block: FunctionalExpressionRing<T, A>.() -> Expression<T>): Expression<T> =
     FunctionalExpressionRing(this).block()
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/expressionBuilders.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/expressionBuilders.kt
index 0ef6803d6..fbf080032 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/expressionBuilders.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/expressionBuilders.kt
@@ -2,18 +2,18 @@ package space.kscience.kmath.expressions
 
 import space.kscience.kmath.operations.ExtendedField
 import space.kscience.kmath.operations.Field
+import space.kscience.kmath.operations.Group
 import space.kscience.kmath.operations.Ring
-import space.kscience.kmath.operations.Space
 import kotlin.contracts.InvocationKind
 import kotlin.contracts.contract
 
 
 /**
- * Creates a functional expression with this [Space].
+ * Creates a functional expression with this [Group].
  */
-public inline fun <T> Space<T>.spaceExpression(block: FunctionalExpressionSpace<T, Space<T>>.() -> Expression<T>): Expression<T> {
+public inline fun <T> Group<T>.spaceExpression(block: FunctionalExpressionGroup<T, Group<T>>.() -> Expression<T>): Expression<T> {
     contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) }
-    return FunctionalExpressionSpace(this).block()
+    return FunctionalExpressionGroup(this).block()
 }
 
 /**
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixContext.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixContext.kt
index 639d77e85..b8937885a 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixContext.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixContext.kt
@@ -13,7 +13,7 @@ import kotlin.reflect.KClass
  * @param T the type of items in the matrices.
  * @param M the type of operated matrices.
  */
-public interface MatrixContext<T : Any, out M : Matrix<T>> : SpaceOperations<Matrix<T>> {
+public interface MatrixContext<T : Any, out M : Matrix<T>> : GroupOperations<Matrix<T>> {
     /**
      * Produces a matrix with this context and given dimensions.
      */
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/VectorSpace.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/VectorSpace.kt
index fd3144d24..570c87b81 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/VectorSpace.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/VectorSpace.kt
@@ -1,8 +1,8 @@
 package space.kscience.kmath.linear
 
+import space.kscience.kmath.operations.Group
 import space.kscience.kmath.operations.RealField
 import space.kscience.kmath.operations.Ring
-import space.kscience.kmath.operations.Space
 import space.kscience.kmath.operations.invoke
 import space.kscience.kmath.structures.Buffer
 import space.kscience.kmath.structures.BufferFactory
@@ -11,7 +11,7 @@ import space.kscience.kmath.structures.BufferFactory
  * A linear space for vectors.
  * Could be used on any point-like structure
  */
-public interface VectorSpace<T : Any, A : Ring<T>> : Space<Point<T>> {
+public interface VectorSpace<T : Any, A : Ring<T>> : Group<Point<T>> {
     public val size: Int
     public val algebra: A
     override val zero: Point<T> get() = produce { algebra.zero }
@@ -27,13 +27,13 @@ public interface VectorSpace<T : Any, A : Ring<T>> : Space<Point<T>> {
     //TODO add basis
 
     public companion object {
-        private val realSpaceCache: MutableMap<Int, BufferVectorSpace<Double, RealField>> = hashMapOf()
+        private val realSpaceCache: MutableMap<Int, BufferVectorGroup<Double, RealField>> = hashMapOf()
 
         /**
          * Non-boxing double vector space
          */
-        public fun real(size: Int): BufferVectorSpace<Double, RealField> = realSpaceCache.getOrPut(size) {
-            BufferVectorSpace(
+        public fun real(size: Int): BufferVectorGroup<Double, RealField> = realSpaceCache.getOrPut(size) {
+            BufferVectorGroup(
                 size,
                 RealField,
                 Buffer.Companion::auto
@@ -47,7 +47,7 @@ public interface VectorSpace<T : Any, A : Ring<T>> : Space<Point<T>> {
             size: Int,
             space: A,
             bufferFactory: BufferFactory<T> = Buffer.Companion::boxing,
-        ): BufferVectorSpace<T, A> = BufferVectorSpace(size, space, bufferFactory)
+        ): BufferVectorGroup<T, A> = BufferVectorGroup(size, space, bufferFactory)
 
         /**
          * Automatic buffered vector, unboxed if it is possible
@@ -58,7 +58,7 @@ public interface VectorSpace<T : Any, A : Ring<T>> : Space<Point<T>> {
 }
 
 
-public class BufferVectorSpace<T : Any, A : Ring<T>>(
+public class BufferVectorGroup<T : Any, A : Ring<T>>(
     override val size: Int,
     override val algebra: A,
     public val bufferFactory: BufferFactory<T>,
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/misc/cumulative.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/misc/cumulative.kt
index 380723095..b50e095cf 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/misc/cumulative.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/misc/cumulative.kt
@@ -1,6 +1,6 @@
 package space.kscience.kmath.misc
 
-import space.kscience.kmath.operations.Space
+import space.kscience.kmath.operations.Group
 import space.kscience.kmath.operations.invoke
 import kotlin.jvm.JvmName
 
@@ -37,7 +37,7 @@ public fun <T, R> List<T>.cumulative(initial: R, operation: (R, T) -> R): List<R
 /**
  * Cumulative sum with custom space
  */
-public fun <T> Iterable<T>.cumulativeSum(space: Space<T>): Iterable<T> =
+public fun <T> Iterable<T>.cumulativeSum(space: Group<T>): Iterable<T> =
     space { cumulative(zero) { element: T, sum: T -> sum + element } }
 
 @JvmName("cumulativeSumOfDouble")
@@ -49,7 +49,7 @@ public fun Iterable<Int>.cumulativeSum(): Iterable<Int> = cumulative(0) { elemen
 @JvmName("cumulativeSumOfLong")
 public fun Iterable<Long>.cumulativeSum(): Iterable<Long> = cumulative(0L) { element, sum -> sum + element }
 
-public fun <T> Sequence<T>.cumulativeSum(space: Space<T>): Sequence<T> =
+public fun <T> Sequence<T>.cumulativeSum(space: Group<T>): Sequence<T> =
     space { cumulative(zero) { element: T, sum: T -> sum + element } }
 
 @JvmName("cumulativeSumOfDouble")
@@ -61,7 +61,7 @@ public fun Sequence<Int>.cumulativeSum(): Sequence<Int> = cumulative(0) { elemen
 @JvmName("cumulativeSumOfLong")
 public fun Sequence<Long>.cumulativeSum(): Sequence<Long> = cumulative(0L) { element, sum -> sum + element }
 
-public fun <T> List<T>.cumulativeSum(space: Space<T>): List<T> =
+public fun <T> List<T>.cumulativeSum(space: Group<T>): List<T> =
     space { cumulative(zero) { element: T, sum: T -> sum + element } }
 
 @JvmName("cumulativeSumOfDouble")
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/BufferNDAlgebra.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/BufferNDAlgebra.kt
index ff9c911ac..58d1ea7b1 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/BufferNDAlgebra.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/BufferNDAlgebra.kt
@@ -52,11 +52,11 @@ public interface BufferNDAlgebra<T, A : Algebra<T>> : NDAlgebra<T, A> {
     }
 }
 
-public open class BufferedNDSpace<T, A : Space<T>>(
+public open class BufferedNDGroup<T, A : Group<T>>(
     final override val shape: IntArray,
     final override val elementContext: A,
     final override val bufferFactory: BufferFactory<T>,
-) : NDSpace<T, A>, BufferNDAlgebra<T, A> {
+) : NDGroup<T, A>, BufferNDAlgebra<T, A> {
     override val strides: Strides = DefaultStrides(shape)
     override val zero: NDBuffer<T> by lazy { produce { zero } }
     override fun NDStructure<T>.unaryMinus(): NDStructure<T> = produce { -get(it) }
@@ -66,7 +66,7 @@ public open class BufferedNDRing<T, R : Ring<T>>(
     shape: IntArray,
     elementContext: R,
     bufferFactory: BufferFactory<T>,
-) : BufferedNDSpace<T, R>(shape, elementContext, bufferFactory), NDRing<T, R> {
+) : BufferedNDGroup<T, R>(shape, elementContext, bufferFactory), NDRing<T, R> {
     override val one: NDBuffer<T> by lazy { produce { one } }
 }
 
@@ -80,16 +80,16 @@ public open class BufferedNDField<T, R : Field<T>>(
 }
 
 // space factories
-public fun <T, A : Space<T>> NDAlgebra.Companion.space(
+public fun <T, A : Group<T>> NDAlgebra.Companion.space(
     space: A,
     bufferFactory: BufferFactory<T>,
     vararg shape: Int,
-): BufferedNDSpace<T, A> = BufferedNDSpace(shape, space, bufferFactory)
+): BufferedNDGroup<T, A> = BufferedNDGroup(shape, space, bufferFactory)
 
-public inline fun <T, A : Space<T>, R> A.ndSpace(
+public inline fun <T, A : Group<T>, R> A.ndSpace(
     noinline bufferFactory: BufferFactory<T>,
     vararg shape: Int,
-    action: BufferedNDSpace<T, A>.() -> R,
+    action: BufferedNDGroup<T, A>.() -> R,
 ): R {
     contract { callsInPlace(action, InvocationKind.EXACTLY_ONCE) }
     return NDAlgebra.space(this, bufferFactory, *shape).run(action)
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/NDAlgebra.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/NDAlgebra.kt
index 6b6e887dc..e3ffae74b 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/NDAlgebra.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/NDAlgebra.kt
@@ -54,7 +54,7 @@ public interface NDAlgebra<T, C: Algebra<T>> {
      * Element-wise invocation of function working on [T] on a [NDStructure].
      */
     public operator fun Function1<T, T>.invoke(structure: NDStructure<T>): NDStructure<T> =
-        structure.map() { value -> this@invoke(value) }
+        structure.map { value -> this@invoke(value) }
 
     public companion object
 }
@@ -89,7 +89,7 @@ internal fun <T, C: Algebra<T>> NDAlgebra<T, C>.checkShape(element: NDStructure<
  * @param N the type of ND structure.
  * @param S the type of space of structure elements.
  */
-public interface NDSpace<T, S : Space<T>> : Space<NDStructure<T>>, NDAlgebra<T, S> {
+public interface NDGroup<T, S : Group<T>> : Group<NDStructure<T>>, NDAlgebra<T, S> {
     /**
      * Element-wise addition.
      *
@@ -127,7 +127,7 @@ public interface NDSpace<T, S : Space<T>> : Space<NDStructure<T>>, NDAlgebra<T,
      * @param arg the divisor.
      * @return the quotient.
      */
-    public operator fun NDStructure<T>.minus(arg: T): NDStructure<T> = this.map() { value -> add(arg, -value) }
+    public operator fun NDStructure<T>.minus(arg: T): NDStructure<T> = this.map { value -> add(arg, -value) }
 
     /**
      * Adds an element to ND structure of it.
@@ -136,7 +136,7 @@ public interface NDSpace<T, S : Space<T>> : Space<NDStructure<T>>, NDAlgebra<T,
      * @param arg the augend.
      * @return the sum.
      */
-    public operator fun T.plus(arg: NDStructure<T>): NDStructure<T> = arg.map() { value -> add(this@plus, value) }
+    public operator fun T.plus(arg: NDStructure<T>): NDStructure<T> = arg.map { value -> add(this@plus, value) }
 
     /**
      * Subtracts an ND structure from an element of it.
@@ -145,7 +145,7 @@ public interface NDSpace<T, S : Space<T>> : Space<NDStructure<T>>, NDAlgebra<T,
      * @param arg the divisor.
      * @return the quotient.
      */
-    public operator fun T.minus(arg: NDStructure<T>): NDStructure<T> = arg.map() { value -> add(-this@minus, value) }
+    public operator fun T.minus(arg: NDStructure<T>): NDStructure<T> = arg.map { value -> add(-this@minus, value) }
 
     public companion object
 }
@@ -157,7 +157,7 @@ public interface NDSpace<T, S : Space<T>> : Space<NDStructure<T>>, NDAlgebra<T,
  * @param N the type of ND structure.
  * @param R the type of ring of structure elements.
  */
-public interface NDRing<T, R : Ring<T>> : Ring<NDStructure<T>>, NDSpace<T, R> {
+public interface NDRing<T, R : Ring<T>> : Ring<NDStructure<T>>, NDGroup<T, R> {
     /**
      * Element-wise multiplication.
      *
@@ -177,7 +177,7 @@ public interface NDRing<T, R : Ring<T>> : Ring<NDStructure<T>>, NDSpace<T, R> {
      * @param arg the multiplier.
      * @return the product.
      */
-    public operator fun NDStructure<T>.times(arg: T): NDStructure<T> = this.map() { value -> multiply(arg, value) }
+    public operator fun NDStructure<T>.times(arg: T): NDStructure<T> = this.map { value -> multiply(arg, value) }
 
     /**
      * Multiplies an element by a ND structure of it.
@@ -186,7 +186,7 @@ public interface NDRing<T, R : Ring<T>> : Ring<NDStructure<T>>, NDSpace<T, R> {
      * @param arg the multiplier.
      * @return the product.
      */
-    public operator fun T.times(arg: NDStructure<T>): NDStructure<T> = arg.map() { value -> multiply(this@times, value) }
+    public operator fun T.times(arg: NDStructure<T>): NDStructure<T> = arg.map { value -> multiply(this@times, value) }
 
     public companion object
 }
@@ -217,7 +217,7 @@ public interface NDField<T, F : Field<T>> : Field<NDStructure<T>>, NDRing<T, F>,
      * @param arg the divisor.
      * @return the quotient.
      */
-    public operator fun NDStructure<T>.div(arg: T): NDStructure<T> = this.map() { value -> divide(arg, value) }
+    public operator fun NDStructure<T>.div(arg: T): NDStructure<T> = this.map { value -> divide(arg, value) }
 
     /**
      * Divides an element by an ND structure of it.
@@ -226,7 +226,7 @@ public interface NDField<T, F : Field<T>> : Field<NDStructure<T>>, NDRing<T, F>,
      * @param arg the divisor.
      * @return the quotient.
      */
-    public operator fun T.div(arg: NDStructure<T>): NDStructure<T> = arg.map() { divide(it, this@div) }
+    public operator fun T.div(arg: NDStructure<T>): NDStructure<T> = arg.map { divide(it, this@div) }
 
 //    @ThreadLocal
 //    public companion object {
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/Algebra.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/Algebra.kt
index 2163f61b2..0198700f2 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/Algebra.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/Algebra.kt
@@ -105,7 +105,7 @@ public inline operator fun <A : Algebra<*>, R> A.invoke(block: A.() -> R): R = r
  *
  * @param T the type of element of this semispace.
  */
-public interface SpaceOperations<T> : Algebra<T> {
+public interface GroupOperations<T> : Algebra<T> {
     /**
      * Addition of two elements.
      *
@@ -177,12 +177,11 @@ public interface SpaceOperations<T> : Algebra<T> {
 }
 
 /**
- * Represents linear space with neutral element, i.e. algebraic structure with associative, binary operation [add] and
- * scalar multiplication [multiply].
+ * Represents linear space with neutral element, i.e. algebraic structure with associative, binary operation [add].
  *
  * @param T the type of element of this semispace.
  */
-public interface Space<T> : SpaceOperations<T> {
+public interface Group<T> : GroupOperations<T> {
     /**
      * The neutral element of addition.
      */
@@ -195,7 +194,7 @@ public interface Space<T> : SpaceOperations<T> {
  *
  * @param T the type of element of this semiring.
  */
-public interface RingOperations<T> : SpaceOperations<T> {
+public interface RingOperations<T> : GroupOperations<T> {
     /**
      * Multiplies two elements.
      *
@@ -231,7 +230,7 @@ public interface RingOperations<T> : SpaceOperations<T> {
  *
  * @param T the type of element of this ring.
  */
-public interface Ring<T> : Space<T>, RingOperations<T> {
+public interface Ring<T> : Group<T>, RingOperations<T> {
     /**
      * neutral operation for multiplication
      */
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/AlgebraElements.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/AlgebraElements.kt
index 1fb4f6750..3e42ac094 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/AlgebraElements.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/AlgebraElements.kt
@@ -49,7 +49,7 @@ public operator fun <T : AlgebraElement<T, S>, S : NumbersAddOperations<T>> T.mi
  * @param b the augend.
  * @return the sum.
  */
-public operator fun <T : AlgebraElement<T, S>, S : Space<T>> T.plus(b: T): T =
+public operator fun <T : AlgebraElement<T, S>, S : Group<T>> T.plus(b: T): T =
     context.add(this, b)
 
 ///**
@@ -80,14 +80,14 @@ public operator fun <T : AlgebraElement<T, F>, F : Field<T>> T.div(b: T): T =
 
 
 /**
- * The element of [Space].
+ * The element of [Group].
  *
  * @param T the type of space operation results.
  * @param I self type of the element. Needed for static type checking.
  * @param S the type of space.
  */
 @UnstableKMathAPI
-public interface SpaceElement<T : SpaceElement<T, S>, S : Space<T>> : AlgebraElement<T, S>
+public interface SpaceElement<T : SpaceElement<T, S>, S : Group<T>> : AlgebraElement<T, S>
 
 /**
  * The element of [Ring].
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/NumericAlgebra.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/NumericAlgebra.kt
index 5f6ec869a..bd5f5951f 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/NumericAlgebra.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/NumericAlgebra.kt
@@ -127,7 +127,7 @@ public interface ScaleOperations<T> : Algebra<T> {
  * TODO to be removed and replaced by extensions after multiple receivers are there
  */
 @UnstableKMathAPI
-public interface NumbersAddOperations<T> : Space<T>, NumericAlgebra<T> {
+public interface NumbersAddOperations<T> : Group<T>, NumericAlgebra<T> {
     /**
      * Addition of element and scalar.
      *
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/algebraExtensions.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/algebraExtensions.kt
index 66b16b6f6..52a0dec6f 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/algebraExtensions.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/algebraExtensions.kt
@@ -1,49 +1,49 @@
 package space.kscience.kmath.operations
 
 /**
- * Returns the sum of all elements in the iterable in this [Space].
+ * Returns the sum of all elements in the iterable in this [Group].
  *
  * @receiver the algebra that provides addition.
  * @param data the iterable to sum up.
  * @return the sum.
  */
-public fun <T> Space<T>.sum(data: Iterable<T>): T = data.fold(zero) { left, right -> add(left, right) }
+public fun <T> Group<T>.sum(data: Iterable<T>): T = data.fold(zero) { left, right -> add(left, right) }
 
 /**
- * Returns the sum of all elements in the sequence in this [Space].
+ * Returns the sum of all elements in the sequence in this [Group].
  *
  * @receiver the algebra that provides addition.
  * @param data the sequence to sum up.
  * @return the sum.
  */
-public fun <T> Space<T>.sum(data: Sequence<T>): T = data.fold(zero) { left, right -> add(left, right) }
+public fun <T> Group<T>.sum(data: Sequence<T>): T = data.fold(zero) { left, right -> add(left, right) }
 
 /**
- * Returns an average value of elements in the iterable in this [Space].
+ * Returns an average value of elements in the iterable in this [Group].
  *
  * @receiver the algebra that provides addition and division.
  * @param data the iterable to find average.
  * @return the average value.
  * @author Iaroslav Postovalov
  */
-public fun <T, S> S.average(data: Iterable<T>): T where S : Space<T>, S : ScaleOperations<T> =
+public fun <T, S> S.average(data: Iterable<T>): T where S : Group<T>, S : ScaleOperations<T> =
     sum(data) / data.count()
 
 /**
- * Returns an average value of elements in the sequence in this [Space].
+ * Returns an average value of elements in the sequence in this [Group].
  *
  * @receiver the algebra that provides addition and division.
  * @param data the sequence to find average.
  * @return the average value.
  * @author Iaroslav Postovalov
  */
-public fun <T, S> S.average(data: Sequence<T>): T where S : Space<T>, S : ScaleOperations<T> =
+public fun <T, S> S.average(data: Sequence<T>): T where S : Group<T>, S : ScaleOperations<T> =
     sum(data) / data.count()
 
 /**
  * Absolute of the comparable [value]
  */
-public fun <T : Comparable<T>> Space<T>.abs(value: T): T = if (value > zero) value else -value
+public fun <T : Comparable<T>> Group<T>.abs(value: T): T = if (value > zero) value else -value
 
 /**
  * Returns the sum of all elements in the iterable in provided space.
@@ -52,7 +52,7 @@ public fun <T : Comparable<T>> Space<T>.abs(value: T): T = if (value > zero) val
  * @param space the algebra that provides addition.
  * @return the sum.
  */
-public fun <T> Iterable<T>.sumWith(space: Space<T>): T = space.sum(this)
+public fun <T> Iterable<T>.sumWith(space: Group<T>): T = space.sum(this)
 
 /**
  * Returns the sum of all elements in the sequence in provided space.
@@ -61,28 +61,28 @@ public fun <T> Iterable<T>.sumWith(space: Space<T>): T = space.sum(this)
  * @param space the algebra that provides addition.
  * @return the sum.
  */
-public fun <T> Sequence<T>.sumWith(space: Space<T>): T = space.sum(this)
+public fun <T> Sequence<T>.sumWith(space: Group<T>): T = space.sum(this)
 
 /**
- * Returns an average value of elements in the iterable in this [Space].
+ * Returns an average value of elements in the iterable in this [Group].
  *
  * @receiver the iterable to find average.
  * @param space the algebra that provides addition and division.
  * @return the average value.
  * @author Iaroslav Postovalov
  */
-public fun <T, S> Iterable<T>.averageWith(space: S): T  where S : Space<T>, S : ScaleOperations<T>  =
+public fun <T, S> Iterable<T>.averageWith(space: S): T  where S : Group<T>, S : ScaleOperations<T>  =
     space.average(this)
 
 /**
- * Returns an average value of elements in the sequence in this [Space].
+ * Returns an average value of elements in the sequence in this [Group].
  *
  * @receiver the sequence to find average.
  * @param space the algebra that provides addition and division.
  * @return the average value.
  * @author Iaroslav Postovalov
  */
-public fun <T, S> Sequence<T>.averageWith(space: S): T  where S : Space<T>, S : ScaleOperations<T>  =
+public fun <T, S> Sequence<T>.averageWith(space: S): T  where S : Group<T>, S : ScaleOperations<T>  =
     space.average(this)
 
 //TODO optimized power operation
diff --git a/kmath-core/src/commonTest/kotlin/space/kscience/kmath/testutils/SpaceVerifier.kt b/kmath-core/src/commonTest/kotlin/space/kscience/kmath/testutils/SpaceVerifier.kt
index 6ea75156b..a9cd4454c 100644
--- a/kmath-core/src/commonTest/kotlin/space/kscience/kmath/testutils/SpaceVerifier.kt
+++ b/kmath-core/src/commonTest/kotlin/space/kscience/kmath/testutils/SpaceVerifier.kt
@@ -1,7 +1,7 @@
 package space.kscience.kmath.testutils
 
+import space.kscience.kmath.operations.Group
 import space.kscience.kmath.operations.ScaleOperations
-import space.kscience.kmath.operations.Space
 import space.kscience.kmath.operations.invoke
 import kotlin.test.assertEquals
 import kotlin.test.assertNotEquals
@@ -12,7 +12,7 @@ internal open class SpaceVerifier<T, out S>(
     val b: T,
     val c: T,
     val x: Number,
-) : AlgebraicVerifier<T, Space<T>> where S : Space<T>, S : ScaleOperations<T> {
+) : AlgebraicVerifier<T, Group<T>> where S : Group<T>, S : ScaleOperations<T> {
     override fun verify() {
         algebra {
             assertEquals(a + b + c, a + (b + c), "Addition in $algebra is not associative.")
diff --git a/kmath-coroutines/src/commonMain/kotlin/space/kscience/kmath/chains/flowExtra.kt b/kmath-coroutines/src/commonMain/kotlin/space/kscience/kmath/chains/flowExtra.kt
index eff813bee..81b4327fc 100644
--- a/kmath-coroutines/src/commonMain/kotlin/space/kscience/kmath/chains/flowExtra.kt
+++ b/kmath-coroutines/src/commonMain/kotlin/space/kscience/kmath/chains/flowExtra.kt
@@ -5,16 +5,16 @@ import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.runningReduce
 import kotlinx.coroutines.flow.scan
+import space.kscience.kmath.operations.Group
+import space.kscience.kmath.operations.GroupOperations
 import space.kscience.kmath.operations.ScaleOperations
-import space.kscience.kmath.operations.Space
-import space.kscience.kmath.operations.SpaceOperations
 import space.kscience.kmath.operations.invoke
 
-public fun <T> Flow<T>.cumulativeSum(space: SpaceOperations<T>): Flow<T> =
-    space { runningReduce { sum, element -> sum + element } }
+public fun <T> Flow<T>.cumulativeSum(group: GroupOperations<T>): Flow<T> =
+    group { runningReduce { sum, element -> sum + element } }
 
 @ExperimentalCoroutinesApi
-public fun <T, S> Flow<T>.mean(algebra: S): Flow<T> where S : Space<T>, S : ScaleOperations<T> = algebra {
+public fun <T, S> Flow<T>.mean(algebra: S): Flow<T> where S : Group<T>, S : ScaleOperations<T> = algebra {
     data class Accumulator(var sum: T, var num: Int)
 
     scan(Accumulator(zero, 0)) { sum, element ->
diff --git a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/Polynomial.kt b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/Polynomial.kt
index 9141fa7b9..049909fe1 100644
--- a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/Polynomial.kt
+++ b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/Polynomial.kt
@@ -1,8 +1,8 @@
 package space.kscience.kmath.functions
 
+import space.kscience.kmath.operations.Group
 import space.kscience.kmath.operations.Ring
 import space.kscience.kmath.operations.ScaleOperations
-import space.kscience.kmath.operations.Space
 import space.kscience.kmath.operations.invoke
 import kotlin.contracts.InvocationKind
 import kotlin.contracts.contract
@@ -44,7 +44,7 @@ public fun <T : Any, C : Ring<T>> Polynomial<T>.asFunction(ring: C): (T) -> T =
  */
 public class PolynomialSpace<T : Any, C>(
     private val ring: C,
-) : Space<Polynomial<T>>, ScaleOperations<Polynomial<T>> where C : Ring<T>, C : ScaleOperations<T> {
+) : Group<Polynomial<T>>, ScaleOperations<Polynomial<T>> where C : Ring<T>, C : ScaleOperations<T> {
     public override val zero: Polynomial<T> = Polynomial(emptyList())
 
     override fun Polynomial<T>.unaryMinus(): Polynomial<T> = with(ring) {
diff --git a/kmath-geometry/src/commonMain/kotlin/space/kscience/kmath/geometry/GeometrySpace.kt b/kmath-geometry/src/commonMain/kotlin/space/kscience/kmath/geometry/GeometrySpace.kt
index 392156e9f..808bd692f 100644
--- a/kmath-geometry/src/commonMain/kotlin/space/kscience/kmath/geometry/GeometrySpace.kt
+++ b/kmath-geometry/src/commonMain/kotlin/space/kscience/kmath/geometry/GeometrySpace.kt
@@ -1,10 +1,10 @@
 package space.kscience.kmath.geometry
 
-import space.kscience.kmath.operations.Space
+import space.kscience.kmath.operations.Group
 
 public interface Vector
 
-public interface GeometrySpace<V : Vector> : Space<V> {
+public interface GeometrySpace<V : Vector> : Group<V> {
     /**
      * L2 distance
      */
diff --git a/kmath-histograms/src/commonMain/kotlin/space/kscience/kmath/histogram/Counter.kt b/kmath-histograms/src/commonMain/kotlin/space/kscience/kmath/histogram/Counter.kt
index 55e8c0631..d5f3965d9 100644
--- a/kmath-histograms/src/commonMain/kotlin/space/kscience/kmath/histogram/Counter.kt
+++ b/kmath-histograms/src/commonMain/kotlin/space/kscience/kmath/histogram/Counter.kt
@@ -2,8 +2,8 @@ package space.kscience.kmath.histogram
 
 import kotlinx.atomicfu.atomic
 import kotlinx.atomicfu.getAndUpdate
+import space.kscience.kmath.operations.Group
 import space.kscience.kmath.operations.RealField
-import space.kscience.kmath.operations.Space
 
 /**
  * Common representation for atomic counters
@@ -36,7 +36,7 @@ public class LongCounter : Counter<Long> {
     override val value: Long get() = innerValue.value
 }
 
-public class ObjectCounter<T : Any>(public val space: Space<T>) : Counter<T> {
+public class ObjectCounter<T : Any>(public val space: Group<T>) : Counter<T> {
     private val innerValue = atomic(space.zero)
 
     override fun add(delta: T) {
diff --git a/kmath-histograms/src/commonMain/kotlin/space/kscience/kmath/histogram/IndexedHistogramSpace.kt b/kmath-histograms/src/commonMain/kotlin/space/kscience/kmath/histogram/IndexedHistogramSpace.kt
index b82644481..19128b2ac 100644
--- a/kmath-histograms/src/commonMain/kotlin/space/kscience/kmath/histogram/IndexedHistogramSpace.kt
+++ b/kmath-histograms/src/commonMain/kotlin/space/kscience/kmath/histogram/IndexedHistogramSpace.kt
@@ -6,8 +6,8 @@ import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.nd.NDField
 import space.kscience.kmath.nd.NDStructure
 import space.kscience.kmath.nd.Strides
+import space.kscience.kmath.operations.Group
 import space.kscience.kmath.operations.ScaleOperations
-import space.kscience.kmath.operations.Space
 import space.kscience.kmath.operations.SpaceElement
 import space.kscience.kmath.operations.invoke
 
@@ -43,7 +43,7 @@ public class IndexedHistogram<T : Comparable<T>, V : Any>(
  * A space for producing histograms with values in a NDStructure
  */
 public interface IndexedHistogramSpace<T : Comparable<T>, V : Any>
-    : Space<IndexedHistogram<T, V>>, ScaleOperations<IndexedHistogram<T, V>> {
+    : Group<IndexedHistogram<T, V>>, ScaleOperations<IndexedHistogram<T, V>> {
     //public val valueSpace: Space<V>
     public val strides: Strides
     public val histogramValueSpace: NDField<V, *> //= NDAlgebra.space(valueSpace, Buffer.Companion::boxing, *shape),
diff --git a/kmath-histograms/src/jvmMain/kotlin/space/kscience/kmath/histogram/TreeHistogramSpace.kt b/kmath-histograms/src/jvmMain/kotlin/space/kscience/kmath/histogram/TreeHistogramSpace.kt
index 85e82f515..b2071fa02 100644
--- a/kmath-histograms/src/jvmMain/kotlin/space/kscience/kmath/histogram/TreeHistogramSpace.kt
+++ b/kmath-histograms/src/jvmMain/kotlin/space/kscience/kmath/histogram/TreeHistogramSpace.kt
@@ -2,8 +2,8 @@ package space.kscience.kmath.histogram
 
 import space.kscience.kmath.domains.UnivariateDomain
 import space.kscience.kmath.misc.UnstableKMathAPI
+import space.kscience.kmath.operations.Group
 import space.kscience.kmath.operations.ScaleOperations
-import space.kscience.kmath.operations.Space
 import space.kscience.kmath.structures.Buffer
 import java.util.*
 import kotlin.math.abs
@@ -37,7 +37,7 @@ public class TreeHistogram(
 @UnstableKMathAPI
 public class TreeHistogramSpace(
     public val binFactory: (Double) -> UnivariateDomain,
-) : Space<UnivariateHistogram>, ScaleOperations<UnivariateHistogram> {
+) : Group<UnivariateHistogram>, ScaleOperations<UnivariateHistogram> {
 
     private class BinCounter(val domain: UnivariateDomain, val counter: Counter<Double> = Counter.real()) :
         ClosedFloatingPointRange<Double> by domain.range
diff --git a/kmath-histograms/src/jvmMain/kotlin/space/kscience/kmath/histogram/UnivariateHistogram.kt b/kmath-histograms/src/jvmMain/kotlin/space/kscience/kmath/histogram/UnivariateHistogram.kt
index 96e3d41ae..03bd096d9 100644
--- a/kmath-histograms/src/jvmMain/kotlin/space/kscience/kmath/histogram/UnivariateHistogram.kt
+++ b/kmath-histograms/src/jvmMain/kotlin/space/kscience/kmath/histogram/UnivariateHistogram.kt
@@ -2,7 +2,7 @@ package space.kscience.kmath.histogram
 
 import space.kscience.kmath.domains.UnivariateDomain
 import space.kscience.kmath.misc.UnstableKMathAPI
-import space.kscience.kmath.operations.Space
+import space.kscience.kmath.operations.Group
 import space.kscience.kmath.operations.SpaceElement
 import space.kscience.kmath.structures.Buffer
 import space.kscience.kmath.structures.asSequence
@@ -30,7 +30,7 @@ public class UnivariateBin(
 
 @OptIn(UnstableKMathAPI::class)
 public interface UnivariateHistogram : Histogram<Double, UnivariateBin>,
-    SpaceElement<UnivariateHistogram, Space<UnivariateHistogram>> {
+    SpaceElement<UnivariateHistogram, Group<UnivariateHistogram>> {
     public operator fun get(value: Double): UnivariateBin?
     public override operator fun get(point: Buffer<Double>): UnivariateBin? = get(point[0])
 
diff --git a/kmath-kotlingrad/src/main/kotlin/space/kscience/kmath/kotlingrad/ScalarsAdapters.kt b/kmath-kotlingrad/src/main/kotlin/space/kscience/kmath/kotlingrad/ScalarsAdapters.kt
index 6ca6bc113..82b801f91 100644
--- a/kmath-kotlingrad/src/main/kotlin/space/kscience/kmath/kotlingrad/ScalarsAdapters.kt
+++ b/kmath-kotlingrad/src/main/kotlin/space/kscience/kmath/kotlingrad/ScalarsAdapters.kt
@@ -102,8 +102,8 @@ public fun <X : SFun<X>> MST.toSFun(): SFun<X> = when (this) {
     is MST.Symbolic -> toSVar()
 
     is MST.Unary -> when (operation) {
-        SpaceOperations.PLUS_OPERATION -> +value.toSFun<X>()
-        SpaceOperations.MINUS_OPERATION -> -value.toSFun<X>()
+        GroupOperations.PLUS_OPERATION -> +value.toSFun<X>()
+        GroupOperations.MINUS_OPERATION -> -value.toSFun<X>()
         TrigonometricOperations.SIN_OPERATION -> sin(value.toSFun())
         TrigonometricOperations.COS_OPERATION -> cos(value.toSFun())
         TrigonometricOperations.TAN_OPERATION -> tan(value.toSFun())
@@ -114,8 +114,8 @@ public fun <X : SFun<X>> MST.toSFun(): SFun<X> = when (this) {
     }
 
     is MST.Binary -> when (operation) {
-        SpaceOperations.PLUS_OPERATION -> left.toSFun<X>() + right.toSFun()
-        SpaceOperations.MINUS_OPERATION -> left.toSFun<X>() - right.toSFun()
+        GroupOperations.PLUS_OPERATION -> left.toSFun<X>() + right.toSFun()
+        GroupOperations.MINUS_OPERATION -> left.toSFun<X>() - right.toSFun()
         RingOperations.TIMES_OPERATION -> left.toSFun<X>() * right.toSFun()
         FieldOperations.DIV_OPERATION -> left.toSFun<X>() / right.toSFun()
         PowerOperations.POW_OPERATION -> left.toSFun<X>() pow (right as MST.Numeric).toSConst()
diff --git a/kmath-nd4j/src/main/kotlin/space/kscience/kmath/nd4j/Nd4jArrayAlgebra.kt b/kmath-nd4j/src/main/kotlin/space/kscience/kmath/nd4j/Nd4jArrayAlgebra.kt
index dea74abdc..d8ce1052a 100644
--- a/kmath-nd4j/src/main/kotlin/space/kscience/kmath/nd4j/Nd4jArrayAlgebra.kt
+++ b/kmath-nd4j/src/main/kotlin/space/kscience/kmath/nd4j/Nd4jArrayAlgebra.kt
@@ -70,12 +70,12 @@ public interface Nd4jArrayAlgebra<T, C : Algebra<T>> : NDAlgebra<T, C> {
 }
 
 /**
- * Represents [NDSpace] over [Nd4jArrayStructure].
+ * Represents [NDGroup] over [Nd4jArrayStructure].
  *
  * @param T the type of the element contained in ND structure.
  * @param S the type of space of structure elements.
  */
-public interface Nd4jArraySpace<T, S : Space<T>> : NDSpace<T, S>, Nd4jArrayAlgebra<T, S> {
+public interface Nd4JArrayGroup<T, S : Group<T>> : NDGroup<T, S>, Nd4jArrayAlgebra<T, S> {
 
     public override val zero: Nd4jArrayStructure<T>
         get() = Nd4j.zeros(*shape).wrap()
@@ -100,7 +100,7 @@ public interface Nd4jArraySpace<T, S : Space<T>> : NDSpace<T, S>, Nd4jArrayAlgeb
  * @param R the type of ring of structure elements.
  */
 @OptIn(UnstableKMathAPI::class)
-public interface Nd4jArrayRing<T, R : Ring<T>> : NDRing<T, R>, Nd4jArraySpace<T, R> {
+public interface Nd4jArrayRing<T, R : Ring<T>> : NDRing<T, R>, Nd4JArrayGroup<T, R> {
 
     public override val one: Nd4jArrayStructure<T>
         get() = Nd4j.ones(*shape).wrap()
diff --git a/kmath-stat/src/commonMain/kotlin/space/kscience/kmath/stat/SamplerAlgebra.kt b/kmath-stat/src/commonMain/kotlin/space/kscience/kmath/stat/SamplerAlgebra.kt
index ca2fd58cc..c5ec99dae 100644
--- a/kmath-stat/src/commonMain/kotlin/space/kscience/kmath/stat/SamplerAlgebra.kt
+++ b/kmath-stat/src/commonMain/kotlin/space/kscience/kmath/stat/SamplerAlgebra.kt
@@ -4,8 +4,8 @@ import space.kscience.kmath.chains.Chain
 import space.kscience.kmath.chains.ConstantChain
 import space.kscience.kmath.chains.map
 import space.kscience.kmath.chains.zip
+import space.kscience.kmath.operations.Group
 import space.kscience.kmath.operations.ScaleOperations
-import space.kscience.kmath.operations.Space
 import space.kscience.kmath.operations.invoke
 
 public class BasicSampler<T : Any>(public val chainBuilder: (RandomGenerator) -> Chain<T>) : Sampler<T> {
@@ -19,8 +19,8 @@ public class ConstantSampler<T : Any>(public val value: T) : Sampler<T> {
 /**
  * A space for samplers. Allows to perform simple operations on distributions
  */
-public class SamplerSpace<T : Any, S>(public val algebra: S) : Space<Sampler<T>>,
-    ScaleOperations<Sampler<T>> where S : Space<T>, S : ScaleOperations<T> {
+public class SamplerSpace<T : Any, S>(public val algebra: S) : Group<Sampler<T>>,
+    ScaleOperations<Sampler<T>> where S : Group<T>, S : ScaleOperations<T> {
 
     public override val zero: Sampler<T> = ConstantSampler(algebra.zero)
 
diff --git a/kmath-stat/src/commonMain/kotlin/space/kscience/kmath/stat/Statistic.kt b/kmath-stat/src/commonMain/kotlin/space/kscience/kmath/stat/Statistic.kt
index 4a3103d1b..a9f7cd3e4 100644
--- a/kmath-stat/src/commonMain/kotlin/space/kscience/kmath/stat/Statistic.kt
+++ b/kmath-stat/src/commonMain/kotlin/space/kscience/kmath/stat/Statistic.kt
@@ -66,7 +66,7 @@ public fun <T, I, R> ComposableStatistic<T, I, R>.flow(
  * Arithmetic mean
  */
 public class Mean<T>(
-    private val space: Space<T>,
+    private val space: Group<T>,
     private val division: (sum: T, count: Int) -> T,
 ) : ComposableStatistic<T, Pair<T, Int>, T> {
     public override suspend fun computeIntermediate(data: Buffer<T>): Pair<T, Int> =
-- 
2.34.1


From fd51564628da781426226582f3c315d116106667 Mon Sep 17 00:00:00 2001
From: Alexander Nozik <altavir@gmail.com>
Date: Thu, 11 Mar 2021 10:18:59 +0300
Subject: [PATCH 17/37] Return field get access in algebras

---
 .../kotlin/space/kscience/kmath/ast/MstAlgebra.kt           | 6 +++---
 .../kotlin/space/kscience/kmath/viktor/ViktorNDStructure.kt | 6 ++----
 2 files changed, 5 insertions(+), 7 deletions(-)

diff --git a/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/MstAlgebra.kt b/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/MstAlgebra.kt
index a65027147..16fdfbeac 100644
--- a/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/MstAlgebra.kt
+++ b/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/MstAlgebra.kt
@@ -50,7 +50,7 @@ public object MstGroup : Group<MST>, NumericAlgebra<MST>, ScaleOperations<MST> {
  */
 @OptIn(UnstableKMathAPI::class)
 public object MstRing : Ring<MST>, NumbersAddOperations<MST>, ScaleOperations<MST> {
-    public override val zero: MST.Numeric = MstGroup.zero
+    public override val zero: MST.Numeric  get() = MstGroup.zero
     public override val one: MST.Numeric = number(1.0)
 
     public override fun number(value: Number): MST.Numeric = MstGroup.number(value)
@@ -109,8 +109,8 @@ public object MstField : Field<MST>, NumbersAddOperations<MST>, ScaleOperations<
  * [ExtendedField] over [MST] nodes.
  */
 public object MstExtendedField : ExtendedField<MST>, NumericAlgebra<MST> {
-    public override val zero: MST.Numeric = MstField.zero
-    public override val one: MST.Numeric = MstField.one
+    public override val zero: MST.Numeric get() = MstField.zero
+    public override val one: MST.Numeric get() = MstField.one
 
     public override fun bindSymbol(value: String): MST.Symbolic = MstField.bindSymbol(value)
     public override fun number(value: Number): MST.Numeric = MstRing.number(value)
diff --git a/kmath-viktor/src/main/kotlin/space/kscience/kmath/viktor/ViktorNDStructure.kt b/kmath-viktor/src/main/kotlin/space/kscience/kmath/viktor/ViktorNDStructure.kt
index f5697cea2..d791ed675 100644
--- a/kmath-viktor/src/main/kotlin/space/kscience/kmath/viktor/ViktorNDStructure.kt
+++ b/kmath-viktor/src/main/kotlin/space/kscience/kmath/viktor/ViktorNDStructure.kt
@@ -40,11 +40,9 @@ public class ViktorNDField(public override val shape: IntArray) : NDField<Double
             else -> produce { this@f64Buffer[it] }.f64Buffer
         }
 
-    public override val zero: ViktorNDStructure
-        get() = F64Array.full(init = 0.0, shape = shape).asStructure()
+    public override val zero: ViktorNDStructure by lazy { F64Array.full(init = 0.0, shape = shape).asStructure() }
 
-    public override val one: ViktorNDStructure
-        get() = F64Array.full(init = 1.0, shape = shape).asStructure()
+    public override val one: ViktorNDStructure by lazy { F64Array.full(init = 1.0, shape = shape).asStructure() }
 
     private val strides: Strides = DefaultStrides(shape)
 
-- 
2.34.1


From 803f298d8b27ecd0732bed869a29fd1ce8747ca0 Mon Sep 17 00:00:00 2001
From: Alexander Nozik <altavir@gmail.com>
Date: Thu, 11 Mar 2021 11:28:10 +0300
Subject: [PATCH 18/37] Make vector spaces great again

---
 CHANGELOG.md                                  |  1 +
 .../space/kscience/kmath/ast/MstExpression.kt |  6 +--
 .../TestESTreeConsistencyWithInterpreter.kt   |  4 +-
 .../estree/TestESTreeOperationsSupport.kt     |  6 +--
 .../asm/TestAsmConsistencyWithInterpreter.kt  |  4 +-
 .../kmath/asm/TestAsmOperationsSupport.kt     |  6 +--
 .../kscience/kmath/commons/linear/CMMatrix.kt |  3 ++
 kmath-core/api/kmath-core.api                 | 48 ++++++++++++++-----
 .../kscience/kmath/linear/BufferMatrix.kt     | 14 ++++--
 .../kscience/kmath/linear/MatrixContext.kt    | 18 +++----
 .../kscience/kmath/linear/MatrixWrapper.kt    | 31 +++++++-----
 .../kscience/kmath/linear/VectorSpace.kt      | 27 ++++++-----
 .../kscience/kmath/geometry/GeometrySpace.kt  |  3 +-
 13 files changed, 109 insertions(+), 62 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a172eb69a..05c956de3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,7 @@
 ### Changed
 - Exponential operations merged with hyperbolic functions
 - Space is replaced by Group. Space is reserved for vector spaces.
+- VectorSpace is now a vector space
 
 ### Deprecated
 
diff --git a/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/MstExpression.kt b/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/MstExpression.kt
index 3a598fb8c..63dfb38f7 100644
--- a/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/MstExpression.kt
+++ b/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/MstExpression.kt
@@ -58,7 +58,7 @@ public inline fun <reified T : Any, A : Algebra<T>, E : Algebra<MST>> A.mst(
  *
  * @author Alexander Nozik
  */
-public inline fun <reified T : Any, A : Group<T>> A.mstInSpace(block: MstGroup.() -> MST): MstExpression<T, A> {
+public inline fun <reified T : Any, A : Group<T>> A.mstInGroup(block: MstGroup.() -> MST): MstExpression<T, A> {
     contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) }
     return MstExpression(this, MstGroup.block())
 }
@@ -98,9 +98,9 @@ public inline fun <reified T : Any, A : ExtendedField<T>> A.mstInExtendedField(b
  *
  * @author Alexander Nozik
  */
-public inline fun <reified T : Any, A : Group<T>> FunctionalExpressionGroup<T, A>.mstInSpace(block: MstGroup.() -> MST): MstExpression<T, A> {
+public inline fun <reified T : Any, A : Group<T>> FunctionalExpressionGroup<T, A>.mstInGroup(block: MstGroup.() -> MST): MstExpression<T, A> {
     contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) }
-    return algebra.mstInSpace(block)
+    return algebra.mstInGroup(block)
 }
 
 /**
diff --git a/kmath-ast/src/jsTest/kotlin/space/kscience/kmath/estree/TestESTreeConsistencyWithInterpreter.kt b/kmath-ast/src/jsTest/kotlin/space/kscience/kmath/estree/TestESTreeConsistencyWithInterpreter.kt
index 34e9dd945..bb34254b1 100644
--- a/kmath-ast/src/jsTest/kotlin/space/kscience/kmath/estree/TestESTreeConsistencyWithInterpreter.kt
+++ b/kmath-ast/src/jsTest/kotlin/space/kscience/kmath/estree/TestESTreeConsistencyWithInterpreter.kt
@@ -12,7 +12,7 @@ import kotlin.test.assertEquals
 internal class TestESTreeConsistencyWithInterpreter {
     @Test
     fun mstSpace() {
-        val res1 = MstGroup.mstInSpace {
+        val res1 = MstGroup.mstInGroup {
             binaryOperationFunction("+")(
                 unaryOperationFunction("+")(
                     number(3.toByte()) - (number(2.toByte()) + (scale(
@@ -25,7 +25,7 @@ internal class TestESTreeConsistencyWithInterpreter {
             ) + bindSymbol("x") + zero
         }("x" to MST.Numeric(2))
 
-        val res2 = MstGroup.mstInSpace {
+        val res2 = MstGroup.mstInGroup {
             binaryOperationFunction("+")(
                 unaryOperationFunction("+")(
                     number(3.toByte()) - (number(2.toByte()) + (scale(
diff --git a/kmath-ast/src/jsTest/kotlin/space/kscience/kmath/estree/TestESTreeOperationsSupport.kt b/kmath-ast/src/jsTest/kotlin/space/kscience/kmath/estree/TestESTreeOperationsSupport.kt
index 6e2f85327..27bf2f167 100644
--- a/kmath-ast/src/jsTest/kotlin/space/kscience/kmath/estree/TestESTreeOperationsSupport.kt
+++ b/kmath-ast/src/jsTest/kotlin/space/kscience/kmath/estree/TestESTreeOperationsSupport.kt
@@ -2,7 +2,7 @@ package space.kscience.kmath.estree
 
 import space.kscience.kmath.ast.mstInExtendedField
 import space.kscience.kmath.ast.mstInField
-import space.kscience.kmath.ast.mstInSpace
+import space.kscience.kmath.ast.mstInGroup
 import space.kscience.kmath.expressions.invoke
 import space.kscience.kmath.operations.RealField
 import kotlin.random.Random
@@ -12,14 +12,14 @@ import kotlin.test.assertEquals
 internal class TestESTreeOperationsSupport {
     @Test
     fun testUnaryOperationInvocation() {
-        val expression = RealField.mstInSpace { -bindSymbol("x") }.compile()
+        val expression = RealField.mstInGroup { -bindSymbol("x") }.compile()
         val res = expression("x" to 2.0)
         assertEquals(-2.0, res)
     }
 
     @Test
     fun testBinaryOperationInvocation() {
-        val expression = RealField.mstInSpace { -bindSymbol("x") + number(1.0) }.compile()
+        val expression = RealField.mstInGroup { -bindSymbol("x") + number(1.0) }.compile()
         val res = expression("x" to 2.0)
         assertEquals(-1.0, res)
     }
diff --git a/kmath-ast/src/jvmTest/kotlin/space/kscience/kmath/asm/TestAsmConsistencyWithInterpreter.kt b/kmath-ast/src/jvmTest/kotlin/space/kscience/kmath/asm/TestAsmConsistencyWithInterpreter.kt
index 4be2ee331..7cc1497d0 100644
--- a/kmath-ast/src/jvmTest/kotlin/space/kscience/kmath/asm/TestAsmConsistencyWithInterpreter.kt
+++ b/kmath-ast/src/jvmTest/kotlin/space/kscience/kmath/asm/TestAsmConsistencyWithInterpreter.kt
@@ -12,7 +12,7 @@ import kotlin.test.assertEquals
 internal class TestAsmConsistencyWithInterpreter {
     @Test
     fun mstSpace() {
-        val res1 = MstGroup.mstInSpace {
+        val res1 = MstGroup.mstInGroup {
             binaryOperationFunction("+")(
                 unaryOperationFunction("+")(
                     number(3.toByte()) - (number(2.toByte()) + (scale(
@@ -25,7 +25,7 @@ internal class TestAsmConsistencyWithInterpreter {
             ) + bindSymbol("x") + zero
         }("x" to MST.Numeric(2))
 
-        val res2 = MstGroup.mstInSpace {
+        val res2 = MstGroup.mstInGroup {
             binaryOperationFunction("+")(
                 unaryOperationFunction("+")(
                     number(3.toByte()) - (number(2.toByte()) + (scale(
diff --git a/kmath-ast/src/jvmTest/kotlin/space/kscience/kmath/asm/TestAsmOperationsSupport.kt b/kmath-ast/src/jvmTest/kotlin/space/kscience/kmath/asm/TestAsmOperationsSupport.kt
index e3adc4629..e99075f07 100644
--- a/kmath-ast/src/jvmTest/kotlin/space/kscience/kmath/asm/TestAsmOperationsSupport.kt
+++ b/kmath-ast/src/jvmTest/kotlin/space/kscience/kmath/asm/TestAsmOperationsSupport.kt
@@ -2,7 +2,7 @@ package space.kscience.kmath.asm
 
 import space.kscience.kmath.ast.mstInExtendedField
 import space.kscience.kmath.ast.mstInField
-import space.kscience.kmath.ast.mstInSpace
+import space.kscience.kmath.ast.mstInGroup
 import space.kscience.kmath.expressions.invoke
 import space.kscience.kmath.operations.RealField
 import kotlin.random.Random
@@ -12,14 +12,14 @@ import kotlin.test.assertEquals
 internal class TestAsmOperationsSupport {
     @Test
     fun testUnaryOperationInvocation() {
-        val expression = RealField.mstInSpace { -bindSymbol("x") }.compile()
+        val expression = RealField.mstInGroup { -bindSymbol("x") }.compile()
         val res = expression("x" to 2.0)
         assertEquals(-2.0, res)
     }
 
     @Test
     fun testBinaryOperationInvocation() {
-        val expression = RealField.mstInSpace { -bindSymbol("x") + number(1.0) }.compile()
+        val expression = RealField.mstInGroup { -bindSymbol("x") + number(1.0) }.compile()
         val res = expression("x" to 2.0)
         assertEquals(-1.0, res)
     }
diff --git 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
index 537da5947..393b28973 100644
--- 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
@@ -86,6 +86,9 @@ public object CMMatrixContext : MatrixContext<Double, CMMatrix> {
         }
     }
 
+    override fun scale(a: Matrix<Double>, value: Double): Matrix<Double> = a.toCM().times(value)
+
+
     public override fun Matrix<Double>.dot(other: Matrix<Double>): CMMatrix =
         CMMatrix(toCM().origin.multiply(other.toCM().origin))
 
diff --git a/kmath-core/api/kmath-core.api b/kmath-core/api/kmath-core.api
index eae91c985..8b30e4c05 100644
--- a/kmath-core/api/kmath-core.api
+++ b/kmath-core/api/kmath-core.api
@@ -460,6 +460,8 @@ public final class space/kscience/kmath/linear/BufferMatrixContext : space/kscie
 	public fun binaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public synthetic fun bindSymbol (Ljava/lang/String;)Ljava/lang/Object;
 	public fun bindSymbol (Ljava/lang/String;)Lspace/kscience/kmath/nd/Structure2D;
+	public synthetic fun div (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
+	public fun div (Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Number;)Lspace/kscience/kmath/nd/Structure2D;
 	public fun dot (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/linear/BufferMatrix;
 	public synthetic fun dot (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
 	public fun dot (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
@@ -473,8 +475,14 @@ public final class space/kscience/kmath/linear/BufferMatrixContext : space/kscie
 	public fun point (ILkotlin/jvm/functions/Function1;)Lspace/kscience/kmath/structures/Buffer;
 	public fun produce (IILkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/linear/BufferMatrix;
 	public synthetic fun produce (IILkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/nd/Structure2D;
+	public synthetic fun scale (Ljava/lang/Object;D)Ljava/lang/Object;
+	public fun scale (Lspace/kscience/kmath/nd/Structure2D;D)Lspace/kscience/kmath/nd/Structure2D;
+	public synthetic fun times (Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
+	public fun times (Ljava/lang/Number;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
+	public synthetic fun times (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
 	public fun times (Ljava/lang/Object;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/linear/BufferMatrix;
 	public synthetic fun times (Ljava/lang/Object;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
+	public fun times (Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Number;)Lspace/kscience/kmath/nd/Structure2D;
 	public fun times (Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Object;)Lspace/kscience/kmath/linear/BufferMatrix;
 	public synthetic fun times (Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Object;)Lspace/kscience/kmath/nd/Structure2D;
 	public synthetic fun unaryMinus (Ljava/lang/Object;)Ljava/lang/Object;
@@ -490,8 +498,8 @@ public final class space/kscience/kmath/linear/BufferMatrixContext : space/kscie
 public final class space/kscience/kmath/linear/BufferMatrixContext$Companion {
 }
 
-public final class space/kscience/kmath/linear/BufferVectorGroup : space/kscience/kmath/linear/VectorSpace {
-	public fun <init> (ILspace/kscience/kmath/operations/Ring;Lkotlin/jvm/functions/Function2;)V
+public final class space/kscience/kmath/linear/BufferVectorSpace : space/kscience/kmath/linear/VectorSpace {
+	public fun <init> (ILspace/kscience/kmath/operations/Group;Lkotlin/jvm/functions/Function2;)V
 	public synthetic fun add (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun add (Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
 	public synthetic fun binaryOperation (Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
@@ -499,7 +507,9 @@ public final class space/kscience/kmath/linear/BufferVectorGroup : space/kscienc
 	public fun binaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public synthetic fun bindSymbol (Ljava/lang/String;)Ljava/lang/Object;
 	public fun bindSymbol (Ljava/lang/String;)Lspace/kscience/kmath/structures/Buffer;
-	public fun getAlgebra ()Lspace/kscience/kmath/operations/Ring;
+	public synthetic fun div (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
+	public fun div (Lspace/kscience/kmath/structures/Buffer;Ljava/lang/Number;)Lspace/kscience/kmath/structures/Buffer;
+	public fun getAlgebra ()Lspace/kscience/kmath/operations/Group;
 	public final fun getBufferFactory ()Lkotlin/jvm/functions/Function2;
 	public fun getSize ()I
 	public synthetic fun getZero ()Ljava/lang/Object;
@@ -509,7 +519,12 @@ public final class space/kscience/kmath/linear/BufferVectorGroup : space/kscienc
 	public synthetic fun plus (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun plus (Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
 	public fun produce (Lkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/structures/Buffer;
-	public fun scale (Lspace/kscience/kmath/structures/Buffer;Ljava/lang/Object;)Lspace/kscience/kmath/structures/Buffer;
+	public synthetic fun scale (Ljava/lang/Object;D)Ljava/lang/Object;
+	public fun scale (Lspace/kscience/kmath/structures/Buffer;D)Lspace/kscience/kmath/structures/Buffer;
+	public synthetic fun times (Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
+	public fun times (Ljava/lang/Number;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
+	public synthetic fun times (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
+	public fun times (Lspace/kscience/kmath/structures/Buffer;Ljava/lang/Number;)Lspace/kscience/kmath/structures/Buffer;
 	public synthetic fun unaryMinus (Ljava/lang/Object;)Ljava/lang/Object;
 	public fun unaryMinus (Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
 	public synthetic fun unaryOperation (Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/Object;
@@ -549,12 +564,15 @@ public final class space/kscience/kmath/linear/GenericMatrixContext$DefaultImpls
 	public static fun binaryOperation (Lspace/kscience/kmath/linear/GenericMatrixContext;Ljava/lang/String;Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
 	public static fun binaryOperationFunction (Lspace/kscience/kmath/linear/GenericMatrixContext;Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public static fun bindSymbol (Lspace/kscience/kmath/linear/GenericMatrixContext;Ljava/lang/String;)Lspace/kscience/kmath/nd/Structure2D;
+	public static fun div (Lspace/kscience/kmath/linear/GenericMatrixContext;Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Number;)Lspace/kscience/kmath/nd/Structure2D;
 	public static fun dot (Lspace/kscience/kmath/linear/GenericMatrixContext;Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
 	public static fun dot (Lspace/kscience/kmath/linear/GenericMatrixContext;Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
 	public static fun minus (Lspace/kscience/kmath/linear/GenericMatrixContext;Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
 	public static fun plus (Lspace/kscience/kmath/linear/GenericMatrixContext;Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
 	public static fun point (Lspace/kscience/kmath/linear/GenericMatrixContext;ILkotlin/jvm/functions/Function1;)Lspace/kscience/kmath/structures/Buffer;
+	public static fun times (Lspace/kscience/kmath/linear/GenericMatrixContext;Ljava/lang/Number;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
 	public static fun times (Lspace/kscience/kmath/linear/GenericMatrixContext;Ljava/lang/Object;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
+	public static fun times (Lspace/kscience/kmath/linear/GenericMatrixContext;Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Number;)Lspace/kscience/kmath/nd/Structure2D;
 	public static fun times (Lspace/kscience/kmath/linear/GenericMatrixContext;Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Object;)Lspace/kscience/kmath/nd/Structure2D;
 	public static fun unaryMinus (Lspace/kscience/kmath/linear/GenericMatrixContext;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
 	public static fun unaryOperation (Lspace/kscience/kmath/linear/GenericMatrixContext;Ljava/lang/String;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
@@ -625,7 +643,7 @@ public final class space/kscience/kmath/linear/MatrixBuilderKt {
 	public static final fun row (Lspace/kscience/kmath/nd/Structure2D$Companion;[Ljava/lang/Object;)Lspace/kscience/kmath/nd/Structure2D;
 }
 
-public abstract interface class space/kscience/kmath/linear/MatrixContext : space/kscience/kmath/operations/GroupOperations {
+public abstract interface class space/kscience/kmath/linear/MatrixContext : space/kscience/kmath/operations/GroupOperations, space/kscience/kmath/operations/ScaleOperations {
 	public static final field Companion Lspace/kscience/kmath/linear/MatrixContext$Companion;
 	public abstract fun binaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public abstract fun dot (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
@@ -645,10 +663,13 @@ public final class space/kscience/kmath/linear/MatrixContext$DefaultImpls {
 	public static fun binaryOperation (Lspace/kscience/kmath/linear/MatrixContext;Ljava/lang/String;Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
 	public static fun binaryOperationFunction (Lspace/kscience/kmath/linear/MatrixContext;Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public static fun bindSymbol (Lspace/kscience/kmath/linear/MatrixContext;Ljava/lang/String;)Lspace/kscience/kmath/nd/Structure2D;
+	public static fun div (Lspace/kscience/kmath/linear/MatrixContext;Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Number;)Lspace/kscience/kmath/nd/Structure2D;
 	public static fun minus (Lspace/kscience/kmath/linear/MatrixContext;Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
 	public static fun plus (Lspace/kscience/kmath/linear/MatrixContext;Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
 	public static fun point (Lspace/kscience/kmath/linear/MatrixContext;ILkotlin/jvm/functions/Function1;)Lspace/kscience/kmath/structures/Buffer;
+	public static fun times (Lspace/kscience/kmath/linear/MatrixContext;Ljava/lang/Number;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
 	public static fun times (Lspace/kscience/kmath/linear/MatrixContext;Ljava/lang/Object;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
+	public static fun times (Lspace/kscience/kmath/linear/MatrixContext;Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Number;)Lspace/kscience/kmath/nd/Structure2D;
 	public static fun unaryOperation (Lspace/kscience/kmath/linear/MatrixContext;Ljava/lang/String;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
 	public static fun unaryOperationFunction (Lspace/kscience/kmath/linear/MatrixContext;Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
 	public static fun unaryPlus (Lspace/kscience/kmath/linear/MatrixContext;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
@@ -763,21 +784,21 @@ public final class space/kscience/kmath/linear/UnitFeature : space/kscience/kmat
 	public static final field INSTANCE Lspace/kscience/kmath/linear/UnitFeature;
 }
 
-public abstract interface class space/kscience/kmath/linear/VectorSpace : space/kscience/kmath/operations/Group {
+public abstract interface class space/kscience/kmath/linear/VectorSpace : space/kscience/kmath/operations/Group, space/kscience/kmath/operations/ScaleOperations {
 	public static final field Companion Lspace/kscience/kmath/linear/VectorSpace$Companion;
 	public abstract fun add (Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-	public abstract fun getAlgebra ()Lspace/kscience/kmath/operations/Ring;
+	public abstract fun getAlgebra ()Lspace/kscience/kmath/operations/Group;
 	public abstract fun getSize ()I
 	public abstract fun getZero ()Lspace/kscience/kmath/structures/Buffer;
 	public abstract fun produce (Lkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/structures/Buffer;
-	public abstract fun scale (Lspace/kscience/kmath/structures/Buffer;Ljava/lang/Object;)Lspace/kscience/kmath/structures/Buffer;
+	public abstract fun scale (Lspace/kscience/kmath/structures/Buffer;D)Lspace/kscience/kmath/structures/Buffer;
 	public abstract fun unaryMinus (Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
 }
 
 public final class space/kscience/kmath/linear/VectorSpace$Companion {
-	public final fun buffered (ILspace/kscience/kmath/operations/Ring;Lkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/linear/BufferVectorGroup;
-	public static synthetic fun buffered$default (Lspace/kscience/kmath/linear/VectorSpace$Companion;ILspace/kscience/kmath/operations/Ring;Lkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lspace/kscience/kmath/linear/BufferVectorGroup;
-	public final fun real (I)Lspace/kscience/kmath/linear/BufferVectorGroup;
+	public final fun buffered (ILspace/kscience/kmath/operations/Group;Lkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/linear/BufferVectorSpace;
+	public static synthetic fun buffered$default (Lspace/kscience/kmath/linear/VectorSpace$Companion;ILspace/kscience/kmath/operations/Group;Lkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lspace/kscience/kmath/linear/BufferVectorSpace;
+	public final fun real (I)Lspace/kscience/kmath/linear/BufferVectorSpace;
 }
 
 public final class space/kscience/kmath/linear/VectorSpace$DefaultImpls {
@@ -785,10 +806,13 @@ public final class space/kscience/kmath/linear/VectorSpace$DefaultImpls {
 	public static fun binaryOperation (Lspace/kscience/kmath/linear/VectorSpace;Ljava/lang/String;Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
 	public static fun binaryOperationFunction (Lspace/kscience/kmath/linear/VectorSpace;Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
 	public static fun bindSymbol (Lspace/kscience/kmath/linear/VectorSpace;Ljava/lang/String;)Lspace/kscience/kmath/structures/Buffer;
+	public static fun div (Lspace/kscience/kmath/linear/VectorSpace;Lspace/kscience/kmath/structures/Buffer;Ljava/lang/Number;)Lspace/kscience/kmath/structures/Buffer;
 	public static fun getZero (Lspace/kscience/kmath/linear/VectorSpace;)Lspace/kscience/kmath/structures/Buffer;
 	public static fun minus (Lspace/kscience/kmath/linear/VectorSpace;Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
 	public static fun plus (Lspace/kscience/kmath/linear/VectorSpace;Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-	public static fun scale (Lspace/kscience/kmath/linear/VectorSpace;Lspace/kscience/kmath/structures/Buffer;Ljava/lang/Object;)Lspace/kscience/kmath/structures/Buffer;
+	public static fun scale (Lspace/kscience/kmath/linear/VectorSpace;Lspace/kscience/kmath/structures/Buffer;D)Lspace/kscience/kmath/structures/Buffer;
+	public static fun times (Lspace/kscience/kmath/linear/VectorSpace;Ljava/lang/Number;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
+	public static fun times (Lspace/kscience/kmath/linear/VectorSpace;Lspace/kscience/kmath/structures/Buffer;Ljava/lang/Number;)Lspace/kscience/kmath/structures/Buffer;
 	public static fun unaryMinus (Lspace/kscience/kmath/linear/VectorSpace;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
 	public static fun unaryOperation (Lspace/kscience/kmath/linear/VectorSpace;Ljava/lang/String;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
 	public static fun unaryOperationFunction (Lspace/kscience/kmath/linear/VectorSpace;Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/BufferMatrix.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/BufferMatrix.kt
index ef1d82795..ba7b7358c 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/BufferMatrix.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/BufferMatrix.kt
@@ -3,6 +3,7 @@ package space.kscience.kmath.linear
 import space.kscience.kmath.nd.NDStructure
 import space.kscience.kmath.nd.Structure2D
 import space.kscience.kmath.operations.Ring
+import space.kscience.kmath.operations.ScaleOperations
 import space.kscience.kmath.operations.invoke
 import space.kscience.kmath.structures.Buffer
 import space.kscience.kmath.structures.BufferFactory
@@ -18,15 +19,22 @@ public typealias Matrix<T> = Structure2D<T>
 /**
  * Basic implementation of Matrix space based on [NDStructure]
  */
-public class BufferMatrixContext<T : Any, R : Ring<T>>(
-    public override val elementContext: R,
+public class BufferMatrixContext<T : Any, A>(
+    public override val elementContext: A,
     private val bufferFactory: BufferFactory<T>,
-) : GenericMatrixContext<T, R, BufferMatrix<T>> {
+) : GenericMatrixContext<T, A, BufferMatrix<T>> where A : Ring<T>, A : ScaleOperations<T> {
+
     public override fun produce(rows: Int, columns: Int, initializer: (i: Int, j: Int) -> T): BufferMatrix<T> {
         val buffer = bufferFactory(rows * columns) { offset -> initializer(offset / columns, offset % columns) }
         return BufferMatrix(rows, columns, buffer)
     }
 
+    override fun scale(a: Matrix<T>, value: Double): Matrix<T> = elementContext {
+        produce(a.rowNum, a.colNum) { i, j ->
+            a[i, j] * value
+        }
+    }
+
     public override fun point(size: Int, initializer: (Int) -> T): Point<T> = bufferFactory(size, initializer)
 
     private fun Matrix<T>.toBufferMatrix(): BufferMatrix<T> = if (this is BufferMatrix) this else {
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixContext.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixContext.kt
index b8937885a..6afec94e8 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixContext.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixContext.kt
@@ -13,7 +13,7 @@ import kotlin.reflect.KClass
  * @param T the type of items in the matrices.
  * @param M the type of operated matrices.
  */
-public interface MatrixContext<T : Any, out M : Matrix<T>> : GroupOperations<Matrix<T>> {
+public interface MatrixContext<T : Any, out M : Matrix<T>> : GroupOperations<Matrix<T>>, ScaleOperations<Matrix<T>> {
     /**
      * Produces a matrix with this context and given dimensions.
      */
@@ -28,7 +28,7 @@ public interface MatrixContext<T : Any, out M : Matrix<T>> : GroupOperations<Mat
     public override fun binaryOperationFunction(operation: String): (left: Matrix<T>, right: Matrix<T>) -> M =
         when (operation) {
             "dot" -> { left, right -> left dot right }
-            else -> super.binaryOperationFunction(operation) as (Matrix<T>, Matrix<T>) -> M
+            else -> super<GroupOperations>.binaryOperationFunction(operation) as (Matrix<T>, Matrix<T>) -> M
         }
 
     /**
@@ -84,15 +84,15 @@ public interface MatrixContext<T : Any, out M : Matrix<T>> : GroupOperations<Mat
         /**
          * A structured matrix with custom buffer
          */
-        public fun <T : Any, R : Ring<T>> buffered(
-            ring: R,
+        public fun <T : Any, A> buffered(
+            ring: A,
             bufferFactory: BufferFactory<T> = Buffer.Companion::boxing,
-        ): GenericMatrixContext<T, R, BufferMatrix<T>> = BufferMatrixContext(ring, bufferFactory)
+        ): GenericMatrixContext<T, A, BufferMatrix<T>> where A : Ring<T>, A: ScaleOperations<T> = BufferMatrixContext(ring, bufferFactory)
 
         /**
          * Automatic buffered matrix, unboxed if it is possible
          */
-        public inline fun <reified T : Any, R : Ring<T>> auto(ring: R): GenericMatrixContext<T, R, BufferMatrix<T>> =
+        public inline fun <reified T : Any, A> auto(ring: A): GenericMatrixContext<T, A, BufferMatrix<T>> where A : Ring<T>, A: ScaleOperations<T> =
             buffered(ring, Buffer.Companion::auto)
     }
 }
@@ -116,14 +116,14 @@ public inline fun <T : Any, reified F : Any> MatrixContext<T, *>.getFeature(m: M
  * Partial implementation of [MatrixContext] for matrices of [Ring].
  *
  * @param T the type of items in the matrices.
- * @param R the type of ring of matrix elements.
+ * @param A the type of ring of matrix elements.
  * @param M the type of operated matrices.
  */
-public interface GenericMatrixContext<T : Any, R : Ring<T>, out M : Matrix<T>> : MatrixContext<T, M> {
+public interface GenericMatrixContext<T : Any, A, out M : Matrix<T>> : MatrixContext<T, M> where A : Ring<T>, A : ScaleOperations<T>{
     /**
      * The ring over matrix elements.
      */
-    public val elementContext: R
+    public val elementContext: A
 
     public override infix fun Matrix<T>.dot(other: Matrix<T>): M {
         //TODO add typed error
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixWrapper.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixWrapper.kt
index 86ec0de88..69e4a916f 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixWrapper.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixWrapper.kt
@@ -4,6 +4,7 @@ import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.nd.Structure2D
 import space.kscience.kmath.nd.getFeature
 import space.kscience.kmath.operations.Ring
+import space.kscience.kmath.operations.ScaleOperations
 import space.kscience.kmath.structures.asBuffer
 import kotlin.math.sqrt
 import kotlin.reflect.KClass
@@ -14,7 +15,7 @@ import kotlin.reflect.safeCast
  *
  * @param T the type of items.
  */
-public class MatrixWrapper<T : Any> internal  constructor(
+public class MatrixWrapper<T : Any> internal constructor(
     public val origin: Matrix<T>,
     public val features: Set<MatrixFeature>,
 ) : Matrix<T> by origin {
@@ -73,17 +74,23 @@ public fun <T : Any> Structure2D.Companion.square(vararg elements: T): Matrix<T>
 /**
  * Diagonal matrix of ones. The matrix is virtual no actual matrix is created
  */
-public fun <T : Any, R : Ring<T>> GenericMatrixContext<T, R, *>.one(rows: Int, columns: Int): Matrix<T> =
-    VirtualMatrix(rows, columns) { i, j ->
-        if (i == j) elementContext.one else elementContext.zero
-    } + UnitFeature
+public fun <T : Any, A> GenericMatrixContext<T, A, *>.one(
+    rows: Int,
+    columns: Int,
+): Matrix<T> where A : Ring<T>, A : ScaleOperations<T> = VirtualMatrix(rows, columns) { i, j ->
+    if (i == j) elementContext.one else elementContext.zero
+} + UnitFeature
 
 
 /**
  * A virtual matrix of zeroes
  */
-public fun <T : Any, R : Ring<T>> GenericMatrixContext<T, R, *>.zero(rows: Int, columns: Int): Matrix<T> =
-    VirtualMatrix(rows, columns) { _, _ -> elementContext.zero } + ZeroFeature
+public fun <T : Any, A> GenericMatrixContext<T, A, *>.zero(
+    rows: Int,
+    columns: Int,
+): Matrix<T> where A : Ring<T>, A : ScaleOperations<T> = VirtualMatrix(rows, columns) { _, _ ->
+    elementContext.zero
+} + ZeroFeature
 
 public class TransposedFeature<T : Any>(public val original: Matrix<T>) : MatrixFeature
 
@@ -91,9 +98,7 @@ public class TransposedFeature<T : Any>(public val original: Matrix<T>) : Matrix
  * Create a virtual transposed matrix without copying anything. `A.transpose().transpose() === A`
  */
 @OptIn(UnstableKMathAPI::class)
-public fun <T : Any> Matrix<T>.transpose(): Matrix<T> {
-    return getFeature<TransposedFeature<T>>()?.original ?: VirtualMatrix(
-        colNum,
-        rowNum,
-    ) { i, j -> get(j, i) } + TransposedFeature(this)
-}
\ No newline at end of file
+public fun <T : Any> Matrix<T>.transpose(): Matrix<T> = getFeature<TransposedFeature<T>>()?.original ?: VirtualMatrix(
+    colNum,
+    rowNum,
+) { i, j -> get(j, i) } + TransposedFeature(this)
\ No newline at end of file
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/VectorSpace.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/VectorSpace.kt
index 570c87b81..cfacf6826 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/VectorSpace.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/VectorSpace.kt
@@ -2,7 +2,7 @@ package space.kscience.kmath.linear
 
 import space.kscience.kmath.operations.Group
 import space.kscience.kmath.operations.RealField
-import space.kscience.kmath.operations.Ring
+import space.kscience.kmath.operations.ScaleOperations
 import space.kscience.kmath.operations.invoke
 import space.kscience.kmath.structures.Buffer
 import space.kscience.kmath.structures.BufferFactory
@@ -11,7 +11,8 @@ import space.kscience.kmath.structures.BufferFactory
  * A linear space for vectors.
  * Could be used on any point-like structure
  */
-public interface VectorSpace<T : Any, A : Ring<T>> : Group<Point<T>> {
+public interface VectorSpace<T : Any, A> : Group<Point<T>>, ScaleOperations<Point<T>>
+        where A : Group<T>, A : ScaleOperations<T> {
     public val size: Int
     public val algebra: A
     override val zero: Point<T> get() = produce { algebra.zero }
@@ -20,20 +21,20 @@ public interface VectorSpace<T : Any, A : Ring<T>> : Group<Point<T>> {
 
     override fun add(a: Point<T>, b: Point<T>): Point<T> = produce { algebra { a[it] + b[it] } }
 
-    public fun scale(a: Point<T>, scale: T): Point<T> = produce { algebra { a[it] * scale } }
+    override fun scale(a: Point<T>, value: Double): Point<T> = produce { algebra.scale(a[it], value) }
 
     override fun Point<T>.unaryMinus(): Point<T> = produce { -get(it) }
 
     //TODO add basis
 
     public companion object {
-        private val realSpaceCache: MutableMap<Int, BufferVectorGroup<Double, RealField>> = hashMapOf()
+        private val realSpaceCache: MutableMap<Int, BufferVectorSpace<Double, RealField>> = hashMapOf()
 
         /**
          * Non-boxing double vector space
          */
-        public fun real(size: Int): BufferVectorGroup<Double, RealField> = realSpaceCache.getOrPut(size) {
-            BufferVectorGroup(
+        public fun real(size: Int): BufferVectorSpace<Double, RealField> = realSpaceCache.getOrPut(size) {
+            BufferVectorSpace(
                 size,
                 RealField,
                 Buffer.Companion::auto
@@ -43,25 +44,29 @@ public interface VectorSpace<T : Any, A : Ring<T>> : Group<Point<T>> {
         /**
          * A structured vector space with custom buffer
          */
-        public fun <T : Any, A : Ring<T>> buffered(
+        public fun <T : Any, A> buffered(
             size: Int,
             space: A,
             bufferFactory: BufferFactory<T> = Buffer.Companion::boxing,
-        ): BufferVectorGroup<T, A> = BufferVectorGroup(size, space, bufferFactory)
+        ): BufferVectorSpace<T, A> where A : Group<T>, A : ScaleOperations<T> =
+            BufferVectorSpace(size, space, bufferFactory)
 
         /**
          * Automatic buffered vector, unboxed if it is possible
          */
-        public inline fun <reified T : Any, A : Ring<T>> auto(size: Int, space: A): VectorSpace<T, A> =
+        public inline fun <reified T : Any, A> auto(
+            size: Int,
+            space: A,
+        ): VectorSpace<T, A> where A : Group<T>, A : ScaleOperations<T> =
             buffered(size, space, Buffer.Companion::auto)
     }
 }
 
 
-public class BufferVectorGroup<T : Any, A : Ring<T>>(
+public class BufferVectorSpace<T : Any, A>(
     override val size: Int,
     override val algebra: A,
     public val bufferFactory: BufferFactory<T>,
-) : VectorSpace<T, A> {
+) : VectorSpace<T, A> where A : Group<T>, A : ScaleOperations<T> {
     override fun produce(initializer: A.(Int) -> T): Buffer<T> = bufferFactory(size) { algebra.initializer(it) }
 }
diff --git a/kmath-geometry/src/commonMain/kotlin/space/kscience/kmath/geometry/GeometrySpace.kt b/kmath-geometry/src/commonMain/kotlin/space/kscience/kmath/geometry/GeometrySpace.kt
index 808bd692f..9552c1320 100644
--- a/kmath-geometry/src/commonMain/kotlin/space/kscience/kmath/geometry/GeometrySpace.kt
+++ b/kmath-geometry/src/commonMain/kotlin/space/kscience/kmath/geometry/GeometrySpace.kt
@@ -1,10 +1,11 @@
 package space.kscience.kmath.geometry
 
 import space.kscience.kmath.operations.Group
+import space.kscience.kmath.operations.ScaleOperations
 
 public interface Vector
 
-public interface GeometrySpace<V : Vector> : Group<V> {
+public interface GeometrySpace<V : Vector> : Group<V>, ScaleOperations<V> {
     /**
      * L2 distance
      */
-- 
2.34.1


From d56254196585115d735ca54385202679de13acd1 Mon Sep 17 00:00:00 2001
From: Iaroslav Postovalov <postovalovya@gmail.com>
Date: Fri, 12 Mar 2021 19:23:01 +0700
Subject: [PATCH 19/37] Improve conversion functions for Buffer

---
 kmath-core/api/kmath-core.api                 | 11 ++++----
 .../space/kscience/kmath/structures/Buffer.kt | 26 ++++++++++++++++---
 .../kscience/kmath/structures/FloatBuffer.kt  |  8 +++---
 .../kscience/kmath/structures/IntBuffer.kt    |  8 +++---
 .../kscience/kmath/structures/LongBuffer.kt   |  8 +++---
 .../kscience/kmath/structures/RealBuffer.kt   |  8 +++---
 .../kscience/kmath/structures/ShortBuffer.kt  |  8 +++---
 7 files changed, 54 insertions(+), 23 deletions(-)

diff --git a/kmath-core/api/kmath-core.api b/kmath-core/api/kmath-core.api
index 8b30e4c05..d19c2c640 100644
--- a/kmath-core/api/kmath-core.api
+++ b/kmath-core/api/kmath-core.api
@@ -2314,6 +2314,7 @@ public final class space/kscience/kmath/structures/BufferKt {
 	public static final fun asSequence (Lspace/kscience/kmath/structures/Buffer;)Lkotlin/sequences/Sequence;
 	public static final fun getIndices (Lspace/kscience/kmath/structures/Buffer;)Lkotlin/ranges/IntRange;
 	public static final fun toList (Lspace/kscience/kmath/structures/Buffer;)Ljava/util/List;
+	public static final fun toMutableList (Lspace/kscience/kmath/structures/Buffer;)Ljava/util/List;
 }
 
 public abstract interface class space/kscience/kmath/structures/FlaggedBuffer : space/kscience/kmath/structures/Buffer {
@@ -2376,7 +2377,7 @@ public final class space/kscience/kmath/structures/FloatBufferKt {
 	public static final fun FloatBuffer (ILkotlin/jvm/functions/Function1;)[F
 	public static final fun FloatBuffer ([F)[F
 	public static final fun asBuffer ([F)[F
-	public static final fun getArray (Lspace/kscience/kmath/structures/MutableBuffer;)[F
+	public static final fun toFloatArray (Lspace/kscience/kmath/structures/Buffer;)[F
 }
 
 public final class space/kscience/kmath/structures/IntBuffer : space/kscience/kmath/structures/MutableBuffer {
@@ -2412,7 +2413,7 @@ public final class space/kscience/kmath/structures/IntBufferKt {
 	public static final fun IntBuffer (ILkotlin/jvm/functions/Function1;)[I
 	public static final fun IntBuffer ([I)[I
 	public static final fun asBuffer ([I)[I
-	public static final fun getArray (Lspace/kscience/kmath/structures/MutableBuffer;)[I
+	public static final fun toIntArray (Lspace/kscience/kmath/structures/Buffer;)[I
 }
 
 public final class space/kscience/kmath/structures/ListBuffer : space/kscience/kmath/structures/Buffer {
@@ -2470,7 +2471,7 @@ public final class space/kscience/kmath/structures/LongBufferKt {
 	public static final fun LongBuffer (ILkotlin/jvm/functions/Function1;)[J
 	public static final fun LongBuffer ([J)[J
 	public static final fun asBuffer ([J)[J
-	public static final fun getArray (Lspace/kscience/kmath/structures/MutableBuffer;)[J
+	public static final fun toLongArray (Lspace/kscience/kmath/structures/Buffer;)[J
 }
 
 public class space/kscience/kmath/structures/MemoryBuffer : space/kscience/kmath/structures/Buffer {
@@ -2749,7 +2750,7 @@ public final class space/kscience/kmath/structures/RealBufferKt {
 	public static final fun RealBuffer ([D)[D
 	public static final fun asBuffer ([D)[D
 	public static final fun contentEquals-2uVC2J0 ([D[D)Z
-	public static final fun getArray (Lspace/kscience/kmath/structures/MutableBuffer;)[D
+	public static final fun toDoubleArray (Lspace/kscience/kmath/structures/Buffer;)[D
 }
 
 public final class space/kscience/kmath/structures/ShortBuffer : space/kscience/kmath/structures/MutableBuffer {
@@ -2785,7 +2786,7 @@ public final class space/kscience/kmath/structures/ShortBufferKt {
 	public static final fun ShortBuffer (ILkotlin/jvm/functions/Function1;)[S
 	public static final fun ShortBuffer ([S)[S
 	public static final fun asBuffer ([S)[S
-	public static final fun getArray (Lspace/kscience/kmath/structures/MutableBuffer;)[S
+	public static final fun toShortArray (Lspace/kscience/kmath/structures/Buffer;)[S
 }
 
 public final class space/kscience/kmath/structures/ValueFlag : java/lang/Enum {
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/Buffer.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/Buffer.kt
index 2fccd2eeb..2bde18fce 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/Buffer.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/Buffer.kt
@@ -100,9 +100,29 @@ public fun <T> Buffer<T>.asSequence(): Sequence<T> = Sequence(::iterator)
 public fun <T> Buffer<T>.asIterable(): Iterable<T> = Iterable(::iterator)
 
 /**
- * Converts this [Buffer] to a new [List]
+ * Returns a new [List] containing all elements of this buffer.
  */
-public fun <T> Buffer<T>.toList(): List<T> = asSequence().toList()
+public fun <T> Buffer<T>.toList(): List<T> = when (this) {
+    is ArrayBuffer<T> -> array.toList()
+    is ListBuffer<T> -> list.toList()
+    is MutableListBuffer<T> -> list.toList()
+    else -> asSequence().toList()
+}
+
+/**
+ * Returns a new [MutableList] filled with all elements of this buffer.
+ */
+public fun <T> Buffer<T>.toMutableList(): MutableList<T> = when (this) {
+    is ArrayBuffer<T> -> array.toMutableList()
+    is ListBuffer<T> -> list.toMutableList()
+    is MutableListBuffer<T> -> list.toMutableList()
+    else -> asSequence().toMutableList()
+}
+
+/**
+ * Returns a new [Array] containing all elements of this buffer.
+ */
+public inline fun <reified T> Buffer<T>.toTypedArray(): Array<T> = asSequence().toList().toTypedArray()
 
 /**
  * Returns an [IntRange] of the valid indices for this [Buffer].
@@ -222,7 +242,7 @@ public inline class MutableListBuffer<T>(public val list: MutableList<T>) : Muta
  * @param T the type of elements contained in the buffer.
  * @property array The underlying array.
  */
-public class ArrayBuffer<T>(private val array: Array<T>) : MutableBuffer<T> {
+public class ArrayBuffer<T>(internal val array: Array<T>) : MutableBuffer<T> {
     // Can't inline because array is invariant
     override val size: Int
         get() = array.size
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/FloatBuffer.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/FloatBuffer.kt
index 3839be8e1..9fc7d55f3 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/FloatBuffer.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/FloatBuffer.kt
@@ -36,10 +36,12 @@ public inline fun FloatBuffer(size: Int, init: (Int) -> Float): FloatBuffer = Fl
 public fun FloatBuffer(vararg floats: Float): FloatBuffer = FloatBuffer(floats)
 
 /**
- * Returns a [FloatArray] containing all of the elements of this [MutableBuffer].
+ * Returns a new [FloatArray] containing all of the elements of this [Buffer].
  */
-public val MutableBuffer<out Float>.array: FloatArray
-    get() = (if (this is FloatBuffer) array else FloatArray(size) { get(it) })
+public fun Buffer<Float>.toFloatArray(): FloatArray = when(this) {
+    is FloatBuffer -> array.copyOf()
+    else -> FloatArray(size, ::get)
+}
 
 /**
  * Returns [FloatBuffer] over this array.
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/IntBuffer.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/IntBuffer.kt
index df3289a3e..d3d0f79a5 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/IntBuffer.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/IntBuffer.kt
@@ -35,10 +35,12 @@ public inline fun IntBuffer(size: Int, init: (Int) -> Int): IntBuffer = IntBuffe
 public fun IntBuffer(vararg ints: Int): IntBuffer = IntBuffer(ints)
 
 /**
- * Returns a [IntArray] containing all of the elements of this [MutableBuffer].
+ * Returns a new [IntArray] containing all of the elements of this [Buffer].
  */
-public val MutableBuffer<out Int>.array: IntArray
-    get() = (if (this is IntBuffer) array else IntArray(size) { get(it) })
+public fun Buffer<Int>.toIntArray(): IntArray = when(this) {
+    is IntBuffer -> array.copyOf()
+    else -> IntArray(size, ::get)
+}
 
 /**
  * Returns [IntBuffer] over this array.
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/LongBuffer.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/LongBuffer.kt
index d07d44799..fec358421 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/LongBuffer.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/LongBuffer.kt
@@ -35,10 +35,12 @@ public inline fun LongBuffer(size: Int, init: (Int) -> Long): LongBuffer = LongB
 public fun LongBuffer(vararg longs: Long): LongBuffer = LongBuffer(longs)
 
 /**
- * Returns a [IntArray] containing all of the elements of this [MutableBuffer].
+ * Returns a new [LongArray] containing all of the elements of this [Buffer].
  */
-public val MutableBuffer<out Long>.array: LongArray
-    get() = (if (this is LongBuffer) array else LongArray(size) { get(it) })
+public fun Buffer<Long>.toLongArray(): LongArray = when(this) {
+    is LongBuffer -> array.copyOf()
+    else -> LongArray(size, ::get)
+}
 
 /**
  * Returns [LongBuffer] over this array.
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/RealBuffer.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/RealBuffer.kt
index e53ed85c7..01b533138 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/RealBuffer.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/RealBuffer.kt
@@ -40,10 +40,12 @@ public fun RealBuffer(vararg doubles: Double): RealBuffer = RealBuffer(doubles)
 public fun RealBuffer.contentEquals(vararg doubles: Double): Boolean = array.contentEquals(doubles)
 
 /**
- * Returns a [DoubleArray] containing all of the elements of this [MutableBuffer].
+ * Returns a new [DoubleArray] containing all of the elements of this [Buffer].
  */
-public val MutableBuffer<out Double>.array: DoubleArray
-    get() = (if (this is RealBuffer) array else DoubleArray(size) { get(it) })
+public fun Buffer<Double>.toDoubleArray(): DoubleArray = when(this) {
+    is RealBuffer -> array.copyOf()
+    else -> DoubleArray(size, ::get)
+}
 
 /**
  * Returns [RealBuffer] over this array.
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/ShortBuffer.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/ShortBuffer.kt
index afc472b72..77f128403 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/ShortBuffer.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/ShortBuffer.kt
@@ -33,10 +33,12 @@ public inline fun ShortBuffer(size: Int, init: (Int) -> Short): ShortBuffer = Sh
 public fun ShortBuffer(vararg shorts: Short): ShortBuffer = ShortBuffer(shorts)
 
 /**
- * Returns a [ShortArray] containing all of the elements of this [MutableBuffer].
+ * Returns a new [ShortArray] containing all of the elements of this [Buffer].
  */
-public val MutableBuffer<out Short>.array: ShortArray
-    get() = (if (this is ShortBuffer) array else ShortArray(size) { get(it) })
+public fun Buffer<Short>.toShortArray(): ShortArray = when(this) {
+    is ShortBuffer -> array.copyOf()
+    else -> ShortArray(size, ::get)
+}
 
 /**
  * Returns [ShortBuffer] over this array.
-- 
2.34.1


From 401ca2443db984bb6fc56be9ce1f2761fb6e6000 Mon Sep 17 00:00:00 2001
From: Iaroslav Postovalov <postovalovya@gmail.com>
Date: Fri, 12 Mar 2021 20:00:33 +0700
Subject: [PATCH 20/37] Provide pages workflow for sending Dokka artifacts to
 gh-pages

---
 .github/workflows/pages.yml | 31 +++++++++++++++++++++++++++++++
 gradle.properties           |  2 +-
 2 files changed, 32 insertions(+), 1 deletion(-)
 create mode 100644 .github/workflows/pages.yml

diff --git a/.github/workflows/pages.yml b/.github/workflows/pages.yml
new file mode 100644
index 000000000..29a2ed649
--- /dev/null
+++ b/.github/workflows/pages.yml
@@ -0,0 +1,31 @@
+name: Dokka publication
+
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+  build:
+    runs-on: ubuntu-20.04
+    steps:
+      - name: Checkout the repo
+        uses: actions/checkout@v2
+      - name: Set up JDK 11
+        uses: actions/setup-java@v1
+        with:
+          java-version: 11
+      - name: Cache gradle
+        uses: actions/cache@v2
+        with:
+          path: ~/.gradle/caches
+          key: ubuntu-20.04-gradle-${{ hashFiles('*.gradle.kts') }}
+          restore-keys: |
+            ubuntu-20.04-gradle-
+      - name: Build
+        run: ./gradlew build --no-daemon --stacktrace
+      - name: Deploy to GitHub Pages
+        uses: JamesIves/github-pages-deploy-action@4.1.0
+        with:
+            branch: gh-pages
+            folder: build/dokka/htmlMultiModule
diff --git a/gradle.properties b/gradle.properties
index aadc76c52..e28e22e8e 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -2,7 +2,7 @@ kotlin.code.style=official
 kotlin.mpp.stability.nowarn=true
 kotlin.parallel.tasks.in.project=true
 org.gradle.configureondemand=true
-org.gradle.jvmargs=-XX:MaxMetaspaceSize=512m
+org.gradle.jvmargs=-XX:MaxMetaspaceSize=1G
 org.gradle.parallel=true
 
 kotlin.mpp.enableGranularSourceSetsMetadata=true
-- 
2.34.1


From 9bc8e8fbf9ecfe3178e922f6a7ea23b92eaca207 Mon Sep 17 00:00:00 2001
From: Alexander Nozik <altavir@gmail.com>
Date: Fri, 12 Mar 2021 22:52:18 +0300
Subject: [PATCH 21/37] WIP vector space refactor

---
 .../kscience/kmath/benchmarks/DotBenchmark.kt |  26 +--
 .../benchmarks/LinearAlgebraBenchmark.kt      |  13 +-
 .../structures/StructureWriteBenchmark.kt     |   2 +-
 .../kscience/kmath/commons/linear/CMMatrix.kt |  15 +-
 .../kscience/kmath/commons/linear/CMSolver.kt |   8 +-
 .../kscience/kmath/linear/BufferMatrix.kt     | 144 ------------
 .../kscience/kmath/linear/LinearAlgebra.kt    |   8 +-
 .../kscience/kmath/linear/LinearSpace.kt      | 213 ++++++++++++++++++
 .../kscience/kmath/linear/LupDecomposition.kt |  35 ++-
 .../kscience/kmath/linear/MatrixBuilder.kt    |  52 ++---
 .../kscience/kmath/linear/MatrixContext.kt    | 173 --------------
 .../kscience/kmath/linear/MatrixWrapper.kt    |  30 +--
 ...ealMatrixContext.kt => RealLinearSpace.kt} |  23 +-
 .../kscience/kmath/linear/VectorSpace.kt      |  72 ------
 .../kscience/kmath/linear/VirtualMatrix.kt    |   2 -
 .../space/kscience/kmath/nd/NDStructure.kt    |   6 +-
 .../space/kscience/kmath/nd/Structure1D.kt    |   6 +-
 .../space/kscience/kmath/nd/Structure2D.kt    |  12 +-
 .../kmath/structures/BufferAccessor2D.kt      |   2 +-
 .../space/kscience/kmath/linear/MatrixTest.kt |   6 +-
 .../kscience/kmath/linear/RealLUSolverTest.kt |   8 +-
 .../kscience/kmath/dimensions/Wrappers.kt     |   8 +-
 ...jmlMatrixContext.kt => EjmlLinearSpace.kt} |  16 +-
 .../space/kscience/kmath/real/RealMatrix.kt   |  34 +--
 .../kaceince/kmath/real/RealVectorTest.kt     |   4 +-
 25 files changed, 352 insertions(+), 566 deletions(-)
 delete mode 100644 kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/BufferMatrix.kt
 create mode 100644 kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpace.kt
 delete mode 100644 kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixContext.kt
 rename kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/{RealMatrixContext.kt => RealLinearSpace.kt} (78%)
 delete mode 100644 kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/VectorSpace.kt
 rename kmath-ejml/src/main/kotlin/space/kscience/kmath/ejml/{EjmlMatrixContext.kt => EjmlLinearSpace.kt} (80%)

diff --git a/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/DotBenchmark.kt b/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/DotBenchmark.kt
index 93b5c5549..8fb0c284e 100644
--- a/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/DotBenchmark.kt
+++ b/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/DotBenchmark.kt
@@ -4,11 +4,11 @@ import kotlinx.benchmark.Benchmark
 import kotlinx.benchmark.Blackhole
 import kotlinx.benchmark.Scope
 import kotlinx.benchmark.State
-import space.kscience.kmath.commons.linear.CMMatrixContext
-import space.kscience.kmath.ejml.EjmlMatrixContext
-import space.kscience.kmath.linear.BufferMatrixContext
+import space.kscience.kmath.commons.linear.CMLinearSpace
+import space.kscience.kmath.ejml.EjmlLinearSpace
+import space.kscience.kmath.linear.BufferLinearSpace
 import space.kscience.kmath.linear.Matrix
-import space.kscience.kmath.linear.RealMatrixContext
+import space.kscience.kmath.linear.RealLinearSpace
 import space.kscience.kmath.operations.RealField
 import space.kscience.kmath.operations.invoke
 import space.kscience.kmath.structures.Buffer
@@ -24,44 +24,44 @@ internal class DotBenchmark {
         val matrix1 = Matrix.real(dim, dim) { i, j -> if (i <= j) random.nextDouble() else 0.0 }
         val matrix2 = Matrix.real(dim, dim) { i, j -> if (i <= j) random.nextDouble() else 0.0 }
 
-        val cmMatrix1 = CMMatrixContext { matrix1.toCM() }
-        val cmMatrix2 = CMMatrixContext { matrix2.toCM() }
+        val cmMatrix1 = CMLinearSpace { matrix1.toCM() }
+        val cmMatrix2 = CMLinearSpace { matrix2.toCM() }
 
-        val ejmlMatrix1 = EjmlMatrixContext { matrix1.toEjml() }
-        val ejmlMatrix2 = EjmlMatrixContext { matrix2.toEjml() }
+        val ejmlMatrix1 = EjmlLinearSpace { matrix1.toEjml() }
+        val ejmlMatrix2 = EjmlLinearSpace { matrix2.toEjml() }
     }
 
     @Benchmark
     fun cmDot(blackhole: Blackhole) {
-        CMMatrixContext {
+        CMLinearSpace {
             blackhole.consume(cmMatrix1 dot cmMatrix2)
         }
     }
 
     @Benchmark
     fun ejmlDot(blackhole: Blackhole) {
-        EjmlMatrixContext {
+        EjmlLinearSpace {
             blackhole.consume(ejmlMatrix1 dot ejmlMatrix2)
         }
     }
 
     @Benchmark
     fun ejmlDotWithConversion(blackhole: Blackhole) {
-        EjmlMatrixContext {
+        EjmlLinearSpace {
             blackhole.consume(matrix1 dot matrix2)
         }
     }
 
     @Benchmark
     fun bufferedDot(blackhole: Blackhole) {
-        BufferMatrixContext(RealField, Buffer.Companion::real).invoke {
+        BufferLinearSpace(RealField, Buffer.Companion::real).invoke {
             blackhole.consume(matrix1 dot matrix2)
         }
     }
 
     @Benchmark
     fun realDot(blackhole: Blackhole) {
-        RealMatrixContext {
+        RealLinearSpace {
             blackhole.consume(matrix1 dot matrix2)
         }
     }
diff --git a/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/LinearAlgebraBenchmark.kt b/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/LinearAlgebraBenchmark.kt
index 30cb6c0b9..85759d93c 100644
--- a/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/LinearAlgebraBenchmark.kt
+++ b/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/LinearAlgebraBenchmark.kt
@@ -4,13 +4,12 @@ import kotlinx.benchmark.Benchmark
 import kotlinx.benchmark.Blackhole
 import kotlinx.benchmark.Scope
 import kotlinx.benchmark.State
-import space.kscience.kmath.commons.linear.CMMatrixContext
-import space.kscience.kmath.commons.linear.CMMatrixContext.dot
+import space.kscience.kmath.commons.linear.CMLinearSpace
 import space.kscience.kmath.commons.linear.inverse
-import space.kscience.kmath.ejml.EjmlMatrixContext
+import space.kscience.kmath.ejml.EjmlLinearSpace
 import space.kscience.kmath.ejml.inverse
+import space.kscience.kmath.linear.LinearSpace
 import space.kscience.kmath.linear.Matrix
-import space.kscience.kmath.linear.MatrixContext
 import space.kscience.kmath.linear.inverseWithLup
 import space.kscience.kmath.linear.real
 import kotlin.random.Random
@@ -29,19 +28,19 @@ internal class LinearAlgebraBenchmark {
 
     @Benchmark
     fun kmathLupInversion(blackhole: Blackhole) {
-        blackhole.consume(MatrixContext.real.inverseWithLup(matrix))
+        blackhole.consume(LinearSpace.real.inverseWithLup(matrix))
     }
 
     @Benchmark
     fun cmLUPInversion(blackhole: Blackhole) {
-        with(CMMatrixContext) {
+        with(CMLinearSpace) {
             blackhole.consume(inverse(matrix))
         }
     }
 
     @Benchmark
     fun ejmlInverse(blackhole: Blackhole) {
-        with(EjmlMatrixContext) {
+        with(EjmlLinearSpace) {
             blackhole.consume(inverse(matrix))
         }
     }
diff --git a/examples/src/main/kotlin/space/kscience/kmath/structures/StructureWriteBenchmark.kt b/examples/src/main/kotlin/space/kscience/kmath/structures/StructureWriteBenchmark.kt
index 13d6f00e4..66d85edff 100644
--- a/examples/src/main/kotlin/space/kscience/kmath/structures/StructureWriteBenchmark.kt
+++ b/examples/src/main/kotlin/space/kscience/kmath/structures/StructureWriteBenchmark.kt
@@ -7,7 +7,7 @@ import kotlin.system.measureTimeMillis
 @Suppress("UNUSED_VARIABLE")
 fun main() {
     val n = 6000
-    val structure = NDStructure.build(intArrayOf(n, n), Buffer.Companion::auto) { 1.0 }
+    val structure = NDStructure.buffered(intArrayOf(n, n), Buffer.Companion::auto) { 1.0 }
     structure.mapToBuffer { it + 1 } // warm-up
     val time1 = measureTimeMillis { val res = structure.mapToBuffer { it + 1 } }
     println("Structure mapping finished in $time1 millis")
diff --git 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
index 393b28973..53f96626d 100644
--- 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
@@ -3,6 +3,7 @@ package space.kscience.kmath.commons.linear
 import org.apache.commons.math3.linear.*
 import space.kscience.kmath.linear.*
 import space.kscience.kmath.misc.UnstableKMathAPI
+import space.kscience.kmath.operations.RealField
 import space.kscience.kmath.structures.RealBuffer
 import kotlin.reflect.KClass
 import kotlin.reflect.cast
@@ -55,7 +56,7 @@ public inline class CMMatrix(public val origin: RealMatrix) : Matrix<Double> {
 
 public fun RealMatrix.asMatrix(): CMMatrix = CMMatrix(this)
 
-public class CMVector(public val origin: RealVector) : Point<Double> {
+public class CMVector(public val origin: RealVector) : Vector<Double> {
     public override val size: Int get() = origin.dimension
 
     public override operator fun get(index: Int): Double = origin.getEntry(index)
@@ -70,8 +71,8 @@ public fun Point<Double>.toCM(): CMVector = if (this is CMVector) this else {
 
 public fun RealVector.toPoint(): CMVector = CMVector(this)
 
-public object CMMatrixContext : MatrixContext<Double, CMMatrix> {
-    public override fun produce(rows: Int, columns: Int, initializer: (i: Int, j: Int) -> Double): CMMatrix {
+public object CMLinearSpace : LinearSpace<Double, RealField> {
+    public override fun buildMatrix(rows: Int, columns: Int, initializer: (i: Int, j: Int) -> Double): CMMatrix {
         val array = Array(rows) { i -> DoubleArray(columns) { j -> initializer(i, j) } }
         return CMMatrix(Array2DRowRealMatrix(array))
     }
@@ -86,17 +87,15 @@ public object CMMatrixContext : MatrixContext<Double, CMMatrix> {
         }
     }
 
-    override fun scale(a: Matrix<Double>, value: Double): Matrix<Double> = a.toCM().times(value)
-
 
     public override fun Matrix<Double>.dot(other: Matrix<Double>): CMMatrix =
         CMMatrix(toCM().origin.multiply(other.toCM().origin))
 
-    public override fun Matrix<Double>.dot(vector: Point<Double>): CMVector =
+    public override fun Matrix<Double>.dot(vector: Vector<Double>): CMVector =
         CMVector(toCM().origin.preMultiply(vector.toCM().origin))
 
     public override operator fun Matrix<Double>.unaryMinus(): CMMatrix =
-        produce(rowNum, colNum) { i, j -> -get(i, j) }
+        buildMatrix(rowNum, colNum) { i, j -> -get(i, j) }
 
     public override fun add(a: Matrix<Double>, b: Matrix<Double>): CMMatrix =
         CMMatrix(a.toCM().origin.multiply(b.toCM().origin))
@@ -108,7 +107,7 @@ public object CMMatrixContext : MatrixContext<Double, CMMatrix> {
 //        CMMatrix(a.toCM().origin.scalarMultiply(k.toDouble()))
 
     public override operator fun Matrix<Double>.times(value: Double): CMMatrix =
-        produce(rowNum, colNum) { i, j -> get(i, j) * value }
+        buildMatrix(rowNum, colNum) { i, j -> get(i, j) * value }
 }
 
 public operator fun CMMatrix.plus(other: CMMatrix): CMMatrix =
diff --git a/kmath-commons/src/main/kotlin/space/kscience/kmath/commons/linear/CMSolver.kt b/kmath-commons/src/main/kotlin/space/kscience/kmath/commons/linear/CMSolver.kt
index 3ce7ca9e6..ff4727aa2 100644
--- a/kmath-commons/src/main/kotlin/space/kscience/kmath/commons/linear/CMSolver.kt
+++ b/kmath-commons/src/main/kotlin/space/kscience/kmath/commons/linear/CMSolver.kt
@@ -12,7 +12,7 @@ public enum class CMDecomposition {
     CHOLESKY
 }
 
-public fun CMMatrixContext.solver(
+public fun CMLinearSpace.solver(
     a: Matrix<Double>,
     decomposition: CMDecomposition = CMDecomposition.LUP
 ): DecompositionSolver = when (decomposition) {
@@ -23,19 +23,19 @@ public fun CMMatrixContext.solver(
     CMDecomposition.CHOLESKY -> CholeskyDecomposition(a.toCM().origin).solver
 }
 
-public fun CMMatrixContext.solve(
+public fun CMLinearSpace.solve(
     a: Matrix<Double>,
     b: Matrix<Double>,
     decomposition: CMDecomposition = CMDecomposition.LUP
 ): CMMatrix = solver(a, decomposition).solve(b.toCM().origin).asMatrix()
 
-public fun CMMatrixContext.solve(
+public fun CMLinearSpace.solve(
     a: Matrix<Double>,
     b: Point<Double>,
     decomposition: CMDecomposition = CMDecomposition.LUP
 ): CMVector = solver(a, decomposition).solve(b.toCM().origin).toPoint()
 
-public fun CMMatrixContext.inverse(
+public fun CMLinearSpace.inverse(
     a: Matrix<Double>,
     decomposition: CMDecomposition = CMDecomposition.LUP
 ): CMMatrix = solver(a, decomposition).inverse.asMatrix()
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/BufferMatrix.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/BufferMatrix.kt
deleted file mode 100644
index ba7b7358c..000000000
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/BufferMatrix.kt
+++ /dev/null
@@ -1,144 +0,0 @@
-package space.kscience.kmath.linear
-
-import space.kscience.kmath.nd.NDStructure
-import space.kscience.kmath.nd.Structure2D
-import space.kscience.kmath.operations.Ring
-import space.kscience.kmath.operations.ScaleOperations
-import space.kscience.kmath.operations.invoke
-import space.kscience.kmath.structures.Buffer
-import space.kscience.kmath.structures.BufferFactory
-import space.kscience.kmath.structures.asSequence
-
-/**
- * Alias for [Structure2D] with more familiar name.
- *
- * @param T the type of items.
- */
-public typealias Matrix<T> = Structure2D<T>
-
-/**
- * Basic implementation of Matrix space based on [NDStructure]
- */
-public class BufferMatrixContext<T : Any, A>(
-    public override val elementContext: A,
-    private val bufferFactory: BufferFactory<T>,
-) : GenericMatrixContext<T, A, BufferMatrix<T>> where A : Ring<T>, A : ScaleOperations<T> {
-
-    public override fun produce(rows: Int, columns: Int, initializer: (i: Int, j: Int) -> T): BufferMatrix<T> {
-        val buffer = bufferFactory(rows * columns) { offset -> initializer(offset / columns, offset % columns) }
-        return BufferMatrix(rows, columns, buffer)
-    }
-
-    override fun scale(a: Matrix<T>, value: Double): Matrix<T> = elementContext {
-        produce(a.rowNum, a.colNum) { i, j ->
-            a[i, j] * value
-        }
-    }
-
-    public override fun point(size: Int, initializer: (Int) -> T): Point<T> = bufferFactory(size, initializer)
-
-    private fun Matrix<T>.toBufferMatrix(): BufferMatrix<T> = if (this is BufferMatrix) this else {
-        produce(rowNum, colNum) { i, j -> get(i, j) }
-    }
-
-    public fun one(rows: Int, columns: Int): Matrix<Double> = VirtualMatrix(rows, columns) { i, j ->
-        if (i == j) 1.0 else 0.0
-    } + DiagonalFeature
-
-    public override infix fun Matrix<T>.dot(other: Matrix<T>): BufferMatrix<T> {
-        require(colNum == other.rowNum) { "Matrix dot operation dimension mismatch: ($rowNum, $colNum) x (${other.rowNum}, ${other.colNum})" }
-        val bufferMatrix = toBufferMatrix()
-        val otherBufferMatrix = other.toBufferMatrix()
-        return elementContext {
-            produce(rowNum, other.colNum) { i, j ->
-                var res = one
-                for (l in 0 until colNum) {
-                    res += bufferMatrix[i, l] * otherBufferMatrix[l, j]
-                }
-                res
-            }
-        }
-    }
-
-    public override infix fun Matrix<T>.dot(vector: Point<T>): Point<T> {
-        require(colNum == vector.size) { "Matrix dot vector operation dimension mismatch: ($rowNum, $colNum) x (${vector.size})" }
-        val bufferMatrix = toBufferMatrix()
-        return elementContext {
-            bufferFactory(rowNum) { i ->
-                var res = one
-                for (j in 0 until colNum) {
-                    res += bufferMatrix[i, j] * vector[j]
-                }
-                res
-            }
-        }
-    }
-
-    override fun add(a: Matrix<T>, b: Matrix<T>): BufferMatrix<T> {
-        require(a.rowNum == b.rowNum) { "Row number mismatch in matrix addition. Left side: ${a.rowNum}, right side: ${b.rowNum}" }
-        require(a.colNum == b.colNum) { "Column number mismatch in matrix addition. Left side: ${a.colNum}, right side: ${b.colNum}" }
-        val aBufferMatrix = a.toBufferMatrix()
-        val bBufferMatrix = b.toBufferMatrix()
-        return elementContext {
-            produce(a.rowNum, a.colNum) { i, j ->
-                aBufferMatrix[i, j] + bBufferMatrix[i, j]
-            }
-        }
-    }
-
-//    override fun multiply(a: Matrix<T>, k: Number): BufferMatrix<T> {
-//        val aBufferMatrix = a.toBufferMatrix()
-//        return elementContext {
-//            produce(a.rowNum, a.colNum) { i, j -> aBufferMatrix[i, j] * k.toDouble() }
-//        }
-//    }
-
-    public companion object
-}
-
-public class BufferMatrix<T : Any>(
-    public override val rowNum: Int,
-    public override val colNum: Int,
-    public val buffer: Buffer<T>,
-) : Matrix<T> {
-
-    init {
-        require(buffer.size == rowNum * colNum) { "Dimension mismatch for matrix structure" }
-    }
-
-    override val shape: IntArray get() = intArrayOf(rowNum, colNum)
-
-    public override operator fun get(index: IntArray): T = get(index[0], index[1])
-    public override operator fun get(i: Int, j: Int): T = buffer[i * colNum + j]
-
-    public override fun elements(): Sequence<Pair<IntArray, T>> = sequence {
-        for (i in 0 until rowNum) for (j in 0 until colNum) yield(intArrayOf(i, j) to get(i, j))
-    }
-
-    public override fun equals(other: Any?): Boolean {
-        if (this === other) return true
-
-        return when (other) {
-            is NDStructure<*> -> NDStructure.contentEquals(this, other)
-            else -> false
-        }
-    }
-
-    override fun hashCode(): Int {
-        var result = rowNum
-        result = 31 * result + colNum
-        result = 31 * result + buffer.hashCode()
-        return result
-    }
-
-    public override fun toString(): String {
-        return if (rowNum <= 5 && colNum <= 5)
-            "Matrix(rowsNum = $rowNum, colNum = $colNum)\n" +
-                    rows.asSequence().joinToString(prefix = "(", postfix = ")", separator = "\n ") { buffer ->
-                        buffer.asSequence().joinToString(separator = "\t") { it.toString() }
-                    }
-        else "Matrix(rowsNum = $rowNum, colNum = $colNum)"
-    }
-
-
-}
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearAlgebra.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearAlgebra.kt
index ea871ccba..265a709e9 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearAlgebra.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearAlgebra.kt
@@ -1,7 +1,7 @@
 package space.kscience.kmath.linear
 
+import space.kscience.kmath.nd.as1D
 import space.kscience.kmath.structures.Buffer
-import space.kscience.kmath.structures.VirtualBuffer
 
 public typealias Point<T> = Buffer<T>
 
@@ -10,16 +10,16 @@ public typealias Point<T> = Buffer<T>
  */
 public interface LinearSolver<T : Any> {
     public fun solve(a: Matrix<T>, b: Matrix<T>): Matrix<T>
-    public fun solve(a: Matrix<T>, b: Point<T>): Point<T> = solve(a, b.asMatrix()).asPoint()
+    public fun solve(a: Matrix<T>, b: Point<T>): Point<T> = solve(a, b.asMatrix()).asVector()
     public fun inverse(a: Matrix<T>): Matrix<T>
 }
 
 /**
  * Convert matrix to vector if it is possible
  */
-public fun <T : Any> Matrix<T>.asPoint(): Point<T> =
+public fun <T : Any> Matrix<T>.asVector(): Vector<T> =
     if (this.colNum == 1)
-        VirtualBuffer(rowNum) { get(it, 0) }
+        as1D()
     else
         error("Can't convert matrix with more than one column to vector")
 
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpace.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpace.kt
new file mode 100644
index 000000000..e0076cda9
--- /dev/null
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpace.kt
@@ -0,0 +1,213 @@
+package space.kscience.kmath.linear
+
+import space.kscience.kmath.misc.UnstableKMathAPI
+import space.kscience.kmath.nd.*
+import space.kscience.kmath.operations.*
+import space.kscience.kmath.structures.Buffer
+import space.kscience.kmath.structures.BufferFactory
+import kotlin.reflect.KClass
+
+/**
+ * Alias for [Structure2D] with more familiar name.
+ *
+ * @param T the type of items.
+ */
+public typealias Matrix<T> = Structure2D<T>
+
+/**
+ * Alias for [Structure1D] with more familiar name.
+ *
+ * @param T the type of items.
+ */
+public typealias Vector<T> = Structure1D<T>
+
+/**
+ * Basic operations on matrices and vectors. Operates on [Matrix].
+ *
+ * @param T the type of items in the matrices.
+ * @param M the type of operated matrices.
+ */
+public interface LinearSpace<T : Any, A : Ring<T>> {
+    public val elementAlgebra: A
+
+    /**
+     * Produces a matrix with this context and given dimensions.
+     */
+    public fun buildMatrix(rows: Int, columns: Int, initializer: A.(i: Int, j: Int) -> T): Matrix<T>
+
+    /**
+     * Produces a point compatible with matrix space (and possibly optimized for it).
+     */
+    public fun buildVector(size: Int, initializer: A.(Int) -> T): Vector<T> =
+        buildMatrix(1, size) { _, j -> initializer(j) }.as1D()
+
+    public operator fun Matrix<T>.unaryMinus(): Matrix<T> = buildMatrix(rowNum, colNum) { i, j ->
+        -get(i, j)
+    }
+
+    public operator fun Vector<T>.unaryMinus(): Vector<T> = buildVector(size) {
+        -get(it)
+    }
+
+    /**
+     * Matrix sum
+     */
+    public operator fun Matrix<T>.plus(other: Matrix<T>): Matrix<T> = buildMatrix(rowNum, colNum) { i, j ->
+        get(i, j) + other[i, j]
+    }
+
+
+    /**
+     * Vector sum
+     */
+    public operator fun Vector<T>.plus(other: Vector<T>): Vector<T> = buildVector(size) {
+        get(it) + other[it]
+    }
+
+    /**
+     * Matrix subtraction
+     */
+    public operator fun Matrix<T>.minus(other: Matrix<T>): Matrix<T> = buildMatrix(rowNum, colNum) { i, j ->
+        get(i, j) - other[i, j]
+    }
+
+    /**
+     * Vector subtraction
+     */
+    public operator fun Vector<T>.minus(other: Vector<T>): Vector<T> = buildVector(size) {
+        get(it) - other[it]
+    }
+
+
+    /**
+     * Computes the dot product of this matrix and another one.
+     *
+     * @receiver the multiplicand.
+     * @param other the multiplier.
+     * @return the dot product.
+     */
+    public infix fun Matrix<T>.dot(other: Matrix<T>): Matrix<T> {
+        require(colNum == other.rowNum) { "Matrix dot operation dimension mismatch: ($rowNum, $colNum) x (${other.rowNum}, ${other.colNum})" }
+        return elementAlgebra {
+            buildMatrix(rowNum, other.colNum) { i, j ->
+                var res = zero
+                for (l in 0 until colNum) {
+                    res += this@dot[i, l] * other[l, j]
+                }
+                res
+            }
+        }
+    }
+
+    /**
+     * Computes the dot product of this matrix and a vector.
+     *
+     * @receiver the multiplicand.
+     * @param vector the multiplier.
+     * @return the dot product.
+     */
+    public infix fun Matrix<T>.dot(vector: Vector<T>): Vector<T> {
+        require(colNum == vector.size) { "Matrix dot vector operation dimension mismatch: ($rowNum, $colNum) x (${vector.size})" }
+        return elementAlgebra {
+            buildVector(rowNum) { i ->
+                var res = one
+                for (j in 0 until colNum) {
+                    res += this@dot[i, j] * vector[j]
+                }
+                res
+            }
+        }
+    }
+
+    /**
+     * Multiplies a matrix by its element.
+     *
+     * @receiver the multiplicand.
+     * @param value the multiplier.
+     * @receiver the product.
+     */
+    public operator fun Matrix<T>.times(value: T): Matrix<T> =
+        buildMatrix(rowNum, colNum) { i, j -> get(i, j) * value }
+
+    /**
+     * Multiplies an element by a matrix of it.
+     *
+     * @receiver the multiplicand.
+     * @param m the multiplier.
+     * @receiver the product.
+     */
+    public operator fun T.times(m: Matrix<T>): Matrix<T> = m * this
+
+    /**
+     * Multiplies a vector by its element.
+     *
+     * @receiver the multiplicand.
+     * @param value the multiplier.
+     * @receiver the product.
+     */
+    public operator fun Vector<T>.times(value: T): Vector<T> =
+        buildVector(size) { i -> get(i) * value }
+
+    /**
+     * Multiplies an element by a vector of it.
+     *
+     * @receiver the multiplicand.
+     * @param v the multiplier.
+     * @receiver the product.
+     */
+    public operator fun T.times(v: Vector<T>): Vector<T> = v * this
+
+    /**
+     * Gets a feature from the matrix. This function may return some additional features to
+     * [space.kscience.kmath.nd.NDStructure.getFeature].
+     *
+     * @param F the type of feature.
+     * @param m the matrix.
+     * @param type the [KClass] instance of [F].
+     * @return a feature object or `null` if it isn't present.
+     */
+    @UnstableKMathAPI
+    public fun <F : Any> getFeature(m: Matrix<T>, type: KClass<F>): F? = m.getFeature(type)
+
+    public companion object {
+
+        /**
+         * A structured matrix with custom buffer
+         */
+        public fun <T : Any, A : Ring<T>> buffered(
+            algebra: A,
+            bufferFactory: BufferFactory<T> = Buffer.Companion::boxing,
+        ): LinearSpace<T, A> = object : LinearSpace<T, A> {
+            override val elementAlgebra: A = algebra
+
+            override fun buildMatrix(
+                rows: Int, columns: Int,
+                initializer: A.(i: Int, j: Int) -> T,
+            ): Matrix<T> = NDStructure.buffered(intArrayOf(rows, columns)) { (i, j) ->
+                algebra.initializer(i, j)
+            }.as2D()
+
+        }
+
+        /**
+         * Automatic buffered matrix, unboxed if it is possible
+         */
+        public inline fun <reified T : Any, A : Ring<T>> auto(ring: A): LinearSpace<T, A> =
+            buffered(ring, Buffer.Companion::auto)
+    }
+}
+
+/**
+ * Gets a feature from the matrix. This function may return some additional features to
+ * [space.kscience.kmath.nd.NDStructure.getFeature].
+ *
+ * @param T the type of items in the matrices.
+ * @param M the type of operated matrices.
+ * @param F the type of feature.
+ * @receiver the [LinearSpace] of [T].
+ * @param m the matrix.
+ * @return a feature object or `null` if it isn't present.
+ */
+@UnstableKMathAPI
+public inline fun <T : Any, reified F : Any> LinearSpace<T, *>.getFeature(m: Matrix<T>): F? = getFeature(m, F::class)
+
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LupDecomposition.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LupDecomposition.kt
index a3d4cbc47..5d68534bc 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LupDecomposition.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LupDecomposition.kt
@@ -12,7 +12,7 @@ import space.kscience.kmath.structures.MutableBufferFactory
  * Common implementation of [LupDecompositionFeature].
  */
 public class LupDecomposition<T : Any>(
-    public val context: MatrixContext<T, Matrix<T>>,
+    public val context: LinearSpace<T, *>,
     public val elementContext: Field<T>,
     public val lu: Matrix<T>,
     public val pivot: IntArray,
@@ -62,15 +62,14 @@ public class LupDecomposition<T : Any>(
 }
 
 @PublishedApi
-internal fun <T : Comparable<T>, F : Field<T>> GenericMatrixContext<T, F, *>.abs(value: T): T =
-    if (value > elementContext.zero) value else elementContext { -value }
+internal fun <T : Comparable<T>> LinearSpace<T, Ring<T>>.abs(value: T): T =
+    if (value > elementAlgebra.zero) value else elementAlgebra { -value }
 
 /**
  * Create a lup decomposition of generic matrix.
  */
-public fun <T : Comparable<T>> MatrixContext<T, Matrix<T>>.lup(
+public fun <T : Comparable<T>> LinearSpace<T, Field<T>>.lup(
     factory: MutableBufferFactory<T>,
-    elementContext: Field<T>,
     matrix: Matrix<T>,
     checkSingular: (T) -> Boolean,
 ): LupDecomposition<T> {
@@ -80,7 +79,7 @@ public fun <T : Comparable<T>> MatrixContext<T, Matrix<T>>.lup(
 
     //TODO just waits for KEEP-176
     BufferAccessor2D(matrix.rowNum, matrix.colNum, factory).run {
-        elementContext {
+        elementAlgebra {
             val lu = create(matrix)
 
             // Initialize permutation array and parity
@@ -142,18 +141,18 @@ public fun <T : Comparable<T>> MatrixContext<T, Matrix<T>>.lup(
                 for (row in col + 1 until m) lu[row, col] /= luDiag
             }
 
-            return LupDecomposition(this@lup, elementContext, lu.collect(), pivot, even)
+            return LupDecomposition(this@lup, elementAlgebra, lu.collect(), pivot, even)
         }
     }
 }
 
-public inline fun <reified T : Comparable<T>, F : Field<T>> GenericMatrixContext<T, F, Matrix<T>>.lup(
+public inline fun <reified T : Comparable<T>> LinearSpace<T, Field<T>>.lup(
     matrix: Matrix<T>,
     noinline checkSingular: (T) -> Boolean,
-): LupDecomposition<T> = lup(MutableBuffer.Companion::auto, elementContext, matrix, checkSingular)
+): LupDecomposition<T> = lup(MutableBuffer.Companion::auto, matrix, checkSingular)
 
-public fun MatrixContext<Double, Matrix<Double>>.lup(matrix: Matrix<Double>): LupDecomposition<Double> =
-    lup(Buffer.Companion::real, RealField, matrix) { it < 1e-11 }
+public fun LinearSpace<Double, RealField>.lup(matrix: Matrix<Double>): LupDecomposition<Double> =
+    lup(Buffer.Companion::real, matrix) { it < 1e-11 }
 
 public fun <T : Any> LupDecomposition<T>.solveWithLup(
     factory: MutableBufferFactory<T>,
@@ -198,7 +197,7 @@ public fun <T : Any> LupDecomposition<T>.solveWithLup(
                 }
             }
 
-            return context.produce(pivot.size, matrix.colNum) { i, j -> bp[i, j] }
+            return context.buildMatrix(pivot.size, matrix.colNum) { i, j -> bp[i, j] }
         }
     }
 }
@@ -210,18 +209,18 @@ public inline fun <reified T : Any> LupDecomposition<T>.solveWithLup(matrix: Mat
  * Solves a system of linear equations *ax = b** using LUP decomposition.
  */
 @OptIn(UnstableKMathAPI::class)
-public inline fun <reified T : Comparable<T>, F : Field<T>> GenericMatrixContext<T, F, Matrix<T>>.solveWithLup(
+public inline fun <reified T : Comparable<T>> LinearSpace<T, Field<T>>.solveWithLup(
     a: Matrix<T>,
     b: Matrix<T>,
     noinline bufferFactory: MutableBufferFactory<T> = MutableBuffer.Companion::auto,
     noinline checkSingular: (T) -> Boolean,
 ): Matrix<T> {
     // Use existing decomposition if it is provided by matrix
-    val decomposition = a.getFeature() ?: lup(bufferFactory, elementContext, a, checkSingular)
+    val decomposition = a.getFeature() ?: lup(bufferFactory, a, checkSingular)
     return decomposition.solveWithLup(bufferFactory, b)
 }
 
-public inline fun <reified T : Comparable<T>, F : Field<T>> GenericMatrixContext<T, F, Matrix<T>>.inverseWithLup(
+public inline fun <reified T : Comparable<T>> LinearSpace<T, Field<T>>.inverseWithLup(
     matrix: Matrix<T>,
     noinline bufferFactory: MutableBufferFactory<T> = MutableBuffer.Companion::auto,
     noinline checkSingular: (T) -> Boolean,
@@ -229,15 +228,15 @@ public inline fun <reified T : Comparable<T>, F : Field<T>> GenericMatrixContext
 
 
 @OptIn(UnstableKMathAPI::class)
-public fun RealMatrixContext.solveWithLup(a: Matrix<Double>, b: Matrix<Double>): Matrix<Double> {
+public fun RealLinearSpace.solveWithLup(a: Matrix<Double>, b: Matrix<Double>): Matrix<Double> {
     // Use existing decomposition if it is provided by matrix
     val bufferFactory: MutableBufferFactory<Double> = MutableBuffer.Companion::real
-    val decomposition: LupDecomposition<Double> = a.getFeature() ?: lup(bufferFactory, RealField, a) { it < 1e-11 }
+    val decomposition: LupDecomposition<Double> = a.getFeature() ?: lup(bufferFactory, a) { it < 1e-11 }
     return decomposition.solveWithLup(bufferFactory, b)
 }
 
 /**
  * Inverses a square matrix using LUP decomposition. Non square matrix will throw a error.
  */
-public fun RealMatrixContext.inverseWithLup(matrix: Matrix<Double>): Matrix<Double> =
+public fun RealLinearSpace.inverseWithLup(matrix: Matrix<Double>): Matrix<Double> =
     solveWithLup(matrix, one(matrix.rowNum, matrix.colNum))
\ No newline at end of file
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixBuilder.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixBuilder.kt
index c96834360..57bea5cb6 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixBuilder.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixBuilder.kt
@@ -1,46 +1,30 @@
 package space.kscience.kmath.linear
 
-import space.kscience.kmath.nd.Structure2D
-import space.kscience.kmath.structures.Buffer
-import space.kscience.kmath.structures.BufferFactory
-import space.kscience.kmath.structures.asBuffer
+import space.kscience.kmath.misc.UnstableKMathAPI
+import space.kscience.kmath.operations.Ring
 
-public class MatrixBuilder(public val rows: Int, public val columns: Int) {
-    public operator fun <T : Any> invoke(vararg elements: T): Matrix<T> {
-        require(rows * columns == elements.size) { "The number of elements ${elements.size} is not equal $rows * $columns" }
-        val buffer = elements.asBuffer()
-        return BufferMatrix(rows, columns, buffer)
-    }
 
-    //TODO add specific matrix builder functions like diagonal, etc
+@UnstableKMathAPI
+public fun <T : Any> LinearSpace<T, Ring<T>>.matrix(rows: Int, columns: Int, vararg elements: T): Matrix<T> {
+    require(rows * columns == elements.size) { "The number of elements ${elements.size} is not equal $rows * $columns" }
+    return buildMatrix(rows, columns) { i, j -> elements[i * columns + j] }
 }
 
-public fun Structure2D.Companion.build(rows: Int, columns: Int): MatrixBuilder = MatrixBuilder(rows, columns)
-
-public fun <T : Any> Structure2D.Companion.row(vararg values: T): Matrix<T> {
-    val buffer = values.asBuffer()
-    return BufferMatrix(1, values.size, buffer)
+@UnstableKMathAPI
+public fun <T : Any> LinearSpace<T, Ring<T>>.vector(vararg elements: T): Vector<T> {
+    return buildVector(elements.size, elements::get)
 }
 
-public inline fun <reified T : Any> Structure2D.Companion.row(
+public inline fun <T : Any> LinearSpace<T, Ring<T>>.row(
     size: Int,
-    factory: BufferFactory<T> = Buffer.Companion::auto,
-    noinline builder: (Int) -> T,
-): Matrix<T> {
-    val buffer = factory(size, builder)
-    return BufferMatrix(1, size, buffer)
-}
+    crossinline builder: (Int) -> T,
+): Matrix<T> = buildMatrix(1, size) { _, j -> builder(j) }
 
-public fun <T : Any> Structure2D.Companion.column(vararg values: T): Matrix<T> {
-    val buffer = values.asBuffer()
-    return BufferMatrix(values.size, 1, buffer)
-}
+public fun <T : Any> LinearSpace<T, Ring<T>>.row(vararg values: T): Matrix<T> = row(values.size, values::get)
 
-public inline fun <reified T : Any> Structure2D.Companion.column(
+public inline fun <T : Any> LinearSpace<T, Ring<T>>.column(
     size: Int,
-    factory: BufferFactory<T> = Buffer.Companion::auto,
-    noinline builder: (Int) -> T,
-): Matrix<T> {
-    val buffer = factory(size, builder)
-    return BufferMatrix(size, 1, buffer)
-}
+    crossinline builder: (Int) -> T,
+): Matrix<T> = buildMatrix(size, 1) { i, _ -> builder(i) }
+
+public fun <T : Any> LinearSpace<T, Ring<T>>.column(vararg values: T): Matrix<T> = column(values.size, values::get)
\ No newline at end of file
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixContext.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixContext.kt
deleted file mode 100644
index 6afec94e8..000000000
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixContext.kt
+++ /dev/null
@@ -1,173 +0,0 @@
-package space.kscience.kmath.linear
-
-import space.kscience.kmath.misc.UnstableKMathAPI
-import space.kscience.kmath.operations.*
-import space.kscience.kmath.structures.Buffer
-import space.kscience.kmath.structures.BufferFactory
-import space.kscience.kmath.structures.asSequence
-import kotlin.reflect.KClass
-
-/**
- * Basic operations on matrices. Operates on [Matrix].
- *
- * @param T the type of items in the matrices.
- * @param M the type of operated matrices.
- */
-public interface MatrixContext<T : Any, out M : Matrix<T>> : GroupOperations<Matrix<T>>, ScaleOperations<Matrix<T>> {
-    /**
-     * Produces a matrix with this context and given dimensions.
-     */
-    public fun produce(rows: Int, columns: Int, initializer: (i: Int, j: Int) -> T): M
-
-    /**
-     * Produces a point compatible with matrix space (and possibly optimized for it).
-     */
-    public fun point(size: Int, initializer: (Int) -> T): Point<T> = Buffer.boxing(size, initializer)
-
-    @Suppress("UNCHECKED_CAST")
-    public override fun binaryOperationFunction(operation: String): (left: Matrix<T>, right: Matrix<T>) -> M =
-        when (operation) {
-            "dot" -> { left, right -> left dot right }
-            else -> super<GroupOperations>.binaryOperationFunction(operation) as (Matrix<T>, Matrix<T>) -> M
-        }
-
-    /**
-     * Computes the dot product of this matrix and another one.
-     *
-     * @receiver the multiplicand.
-     * @param other the multiplier.
-     * @return the dot product.
-     */
-    public infix fun Matrix<T>.dot(other: Matrix<T>): M
-
-    /**
-     * Computes the dot product of this matrix and a vector.
-     *
-     * @receiver the multiplicand.
-     * @param vector the multiplier.
-     * @return the dot product.
-     */
-    public infix fun Matrix<T>.dot(vector: Point<T>): Point<T>
-
-    /**
-     * Multiplies a matrix by its element.
-     *
-     * @receiver the multiplicand.
-     * @param value the multiplier.
-     * @receiver the product.
-     */
-    public operator fun Matrix<T>.times(value: T): M
-
-    /**
-     * Multiplies an element by a matrix of it.
-     *
-     * @receiver the multiplicand.
-     * @param m the multiplier.
-     * @receiver the product.
-     */
-    public operator fun T.times(m: Matrix<T>): M = m * this
-
-    /**
-     * Gets a feature from the matrix. This function may return some additional features to
-     * [kscience.kmath.nd.NDStructure.getFeature].
-     *
-     * @param F the type of feature.
-     * @param m the matrix.
-     * @param type the [KClass] instance of [F].
-     * @return a feature object or `null` if it isn't present.
-     */
-    @UnstableKMathAPI
-    public fun <F : Any> getFeature(m: Matrix<T>, type: KClass<F>): F? = m.getFeature(type)
-
-    public companion object {
-
-        /**
-         * A structured matrix with custom buffer
-         */
-        public fun <T : Any, A> buffered(
-            ring: A,
-            bufferFactory: BufferFactory<T> = Buffer.Companion::boxing,
-        ): GenericMatrixContext<T, A, BufferMatrix<T>> where A : Ring<T>, A: ScaleOperations<T> = BufferMatrixContext(ring, bufferFactory)
-
-        /**
-         * Automatic buffered matrix, unboxed if it is possible
-         */
-        public inline fun <reified T : Any, A> auto(ring: A): GenericMatrixContext<T, A, BufferMatrix<T>> where A : Ring<T>, A: ScaleOperations<T> =
-            buffered(ring, Buffer.Companion::auto)
-    }
-}
-
-/**
- * Gets a feature from the matrix. This function may return some additional features to
- * [kscience.kmath.nd.NDStructure.getFeature].
- *
- * @param T the type of items in the matrices.
- * @param M the type of operated matrices.
- * @param F the type of feature.
- * @receiver the [MatrixContext] of [T].
- * @param m the matrix.
- * @return a feature object or `null` if it isn't present.
- */
-@UnstableKMathAPI
-public inline fun <T : Any, reified F : Any> MatrixContext<T, *>.getFeature(m: Matrix<T>): F? =
-    getFeature(m, F::class)
-
-/**
- * Partial implementation of [MatrixContext] for matrices of [Ring].
- *
- * @param T the type of items in the matrices.
- * @param A the type of ring of matrix elements.
- * @param M the type of operated matrices.
- */
-public interface GenericMatrixContext<T : Any, A, out M : Matrix<T>> : MatrixContext<T, M> where A : Ring<T>, A : ScaleOperations<T>{
-    /**
-     * The ring over matrix elements.
-     */
-    public val elementContext: A
-
-    public override infix fun Matrix<T>.dot(other: Matrix<T>): M {
-        //TODO add typed error
-        require(colNum == other.rowNum) { "Matrix dot operation dimension mismatch: ($rowNum, $colNum) x (${other.rowNum}, ${other.colNum})" }
-
-        return produce(rowNum, other.colNum) { i, j ->
-            val row = rows[i]
-            val column = other.columns[j]
-            elementContext { sum(row.asSequence().zip(column.asSequence(), ::multiply)) }
-        }
-    }
-
-    public override infix fun Matrix<T>.dot(vector: Point<T>): Point<T> {
-        //TODO add typed error
-        require(colNum == vector.size) { "Matrix dot vector operation dimension mismatch: ($rowNum, $colNum) x (${vector.size})" }
-
-        return point(rowNum) { i ->
-            val row = rows[i]
-            elementContext { sum(row.asSequence().zip(vector.asSequence(), ::multiply)) }
-        }
-    }
-
-    public override operator fun Matrix<T>.unaryMinus(): M =
-        produce(rowNum, colNum) { i, j -> elementContext { -get(i, j) } }
-
-    public override fun add(a: Matrix<T>, b: Matrix<T>): M {
-        require(a.rowNum == b.rowNum && a.colNum == b.colNum) {
-            "Matrix operation dimension mismatch. [${a.rowNum},${a.colNum}] + [${b.rowNum},${b.colNum}]"
-        }
-
-        return produce(a.rowNum, a.colNum) { i, j -> elementContext { a[i, j] + b[i, j] } }
-    }
-
-    public override operator fun Matrix<T>.minus(b: Matrix<T>): M {
-        require(rowNum == b.rowNum && colNum == b.colNum) {
-            "Matrix operation dimension mismatch. [$rowNum,$colNum] - [${b.rowNum},${b.colNum}]"
-        }
-
-        return produce(rowNum, colNum) { i, j -> elementContext { get(i, j) + b[i, j] } }
-    }
-//
-//    public override fun multiply(a: Matrix<T>, k: Number): M =
-//        produce(a.rowNum, a.colNum) { i, j -> elementContext { a[i, j] * k } }
-
-    public override operator fun Matrix<T>.times(value: T): M =
-        produce(rowNum, colNum) { i, j -> elementContext { get(i, j) * value } }
-}
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixWrapper.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixWrapper.kt
index 69e4a916f..97f0acd61 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixWrapper.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixWrapper.kt
@@ -1,14 +1,9 @@
 package space.kscience.kmath.linear
 
 import space.kscience.kmath.misc.UnstableKMathAPI
-import space.kscience.kmath.nd.Structure2D
 import space.kscience.kmath.nd.getFeature
 import space.kscience.kmath.operations.Ring
-import space.kscience.kmath.operations.ScaleOperations
-import space.kscience.kmath.structures.asBuffer
-import kotlin.math.sqrt
 import kotlin.reflect.KClass
-import kotlin.reflect.safeCast
 
 /**
  * A [Matrix] that holds [MatrixFeature] objects.
@@ -24,7 +19,8 @@ public class MatrixWrapper<T : Any> internal constructor(
      * Get the first feature matching given class. Does not guarantee that matrix has only one feature matching the criteria
      */
     @UnstableKMathAPI
-    override fun <T : Any> getFeature(type: KClass<T>): T? = type.safeCast(features.find { type.isInstance(it) })
+    @Suppress("UNCHECKED_CAST")
+    override fun <T : Any> getFeature(type: KClass<T>): T? = features.singleOrNull { type.isInstance(it) } as? T
         ?: origin.getFeature(type)
 
     override fun equals(other: Any?): Boolean = origin == other
@@ -61,35 +57,25 @@ public operator fun <T : Any> Matrix<T>.plus(newFeatures: Collection<MatrixFeatu
         MatrixWrapper(this, newFeatures.toSet())
     }
 
-/**
- * Build a square matrix from given elements.
- */
-public fun <T : Any> Structure2D.Companion.square(vararg elements: T): Matrix<T> {
-    val size: Int = sqrt(elements.size.toDouble()).toInt()
-    require(size * size == elements.size) { "The number of elements ${elements.size} is not a full square" }
-    val buffer = elements.asBuffer()
-    return BufferMatrix(size, size, buffer)
-}
-
 /**
  * Diagonal matrix of ones. The matrix is virtual no actual matrix is created
  */
-public fun <T : Any, A> GenericMatrixContext<T, A, *>.one(
+public fun <T : Any> LinearSpace<T, Ring<T>>.one(
     rows: Int,
     columns: Int,
-): Matrix<T> where A : Ring<T>, A : ScaleOperations<T> = VirtualMatrix(rows, columns) { i, j ->
-    if (i == j) elementContext.one else elementContext.zero
+): Matrix<T> = VirtualMatrix(rows, columns) { i, j ->
+    if (i == j) elementAlgebra.one else elementAlgebra.zero
 } + UnitFeature
 
 
 /**
  * A virtual matrix of zeroes
  */
-public fun <T : Any, A> GenericMatrixContext<T, A, *>.zero(
+public fun <T : Any> LinearSpace<T, Ring<T>>.zero(
     rows: Int,
     columns: Int,
-): Matrix<T> where A : Ring<T>, A : ScaleOperations<T> = VirtualMatrix(rows, columns) { _, _ ->
-    elementContext.zero
+): Matrix<T> = VirtualMatrix(rows, columns) { _, _ ->
+    elementAlgebra.zero
 } + ZeroFeature
 
 public class TransposedFeature<T : Any>(public val original: Matrix<T>) : MatrixFeature
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/RealMatrixContext.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/RealLinearSpace.kt
similarity index 78%
rename from kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/RealMatrixContext.kt
rename to kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/RealLinearSpace.kt
index dbccb7536..6dc97c51e 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/RealMatrixContext.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/RealLinearSpace.kt
@@ -1,34 +1,37 @@
 package space.kscience.kmath.linear
 
+import space.kscience.kmath.operations.RealField
 import space.kscience.kmath.operations.ScaleOperations
 import space.kscience.kmath.structures.RealBuffer
 
-public object RealMatrixContext : MatrixContext<Double, BufferMatrix<Double>>, ScaleOperations<Matrix<Double>> {
+public object RealLinearSpace : LinearSpace<Double, RealField>, ScaleOperations<Matrix<Double>> {
 
-    public override fun produce(
+    override val elementAlgebra: RealField get() = RealField
+
+    public override fun buildMatrix(
         rows: Int,
         columns: Int,
         initializer: (i: Int, j: Int) -> Double,
-    ): BufferMatrix<Double> {
+    ): Matrix<Double> {
         val buffer = RealBuffer(rows * columns) { offset -> initializer(offset / columns, offset % columns) }
-        return BufferMatrix(rows, columns, buffer)
+        return  BufferMatrix(rows, columns, buffer)
     }
 
     public fun Matrix<Double>.toBufferMatrix(): BufferMatrix<Double> = if (this is BufferMatrix) this else {
-        produce(rowNum, colNum) { i, j -> get(i, j) }
+        buildMatrix(rowNum, colNum) { i, j -> get(i, j) }
     }
 
     public fun one(rows: Int, columns: Int): Matrix<Double> = VirtualMatrix(rows, columns) { i, j ->
         if (i == j) 1.0 else 0.0
     } + DiagonalFeature
 
-    override fun Matrix<Double>.unaryMinus(): Matrix<Double> = produce(rowNum, colNum) { i, j -> -get(i, j) }
+    override fun Matrix<Double>.unaryMinus(): Matrix<Double> = buildMatrix(rowNum, colNum) { i, j -> -get(i, j) }
 
     public override infix fun Matrix<Double>.dot(other: Matrix<Double>): BufferMatrix<Double> {
         require(colNum == other.rowNum) { "Matrix dot operation dimension mismatch: ($rowNum, $colNum) x (${other.rowNum}, ${other.colNum})" }
         val bufferMatrix = toBufferMatrix()
         val otherBufferMatrix = other.toBufferMatrix()
-        return produce(rowNum, other.colNum) { i, j ->
+        return buildMatrix(rowNum, other.colNum) { i, j ->
             var res = 0.0
             for (l in 0 until colNum) {
                 res += bufferMatrix[i, l] * otherBufferMatrix[l, j]
@@ -54,14 +57,14 @@ public object RealMatrixContext : MatrixContext<Double, BufferMatrix<Double>>, S
         require(a.colNum == b.colNum) { "Column number mismatch in matrix addition. Left side: ${a.colNum}, right side: ${b.colNum}" }
         val aBufferMatrix = a.toBufferMatrix()
         val bBufferMatrix = b.toBufferMatrix()
-        return produce(a.rowNum, a.colNum) { i, j ->
+        return buildMatrix(a.rowNum, a.colNum) { i, j ->
             aBufferMatrix[i, j] + bBufferMatrix[i, j]
         }
     }
 
     override fun scale(a: Matrix<Double>, value: Double): BufferMatrix<Double> {
         val bufferMatrix = a.toBufferMatrix()
-        return produce(a.rowNum, a.colNum) { i, j -> bufferMatrix[i, j] * value }
+        return buildMatrix(a.rowNum, a.colNum) { i, j -> bufferMatrix[i, j] * value }
     }
 
     override fun Matrix<Double>.times(value: Double): BufferMatrix<Double> = scale(this, value)
@@ -82,4 +85,4 @@ public object RealMatrixContext : MatrixContext<Double, BufferMatrix<Double>>, S
 /**
  * Partially optimized real-valued matrix
  */
-public val MatrixContext.Companion.real: RealMatrixContext get() = RealMatrixContext
+public val LinearSpace.Companion.real: RealLinearSpace get() = RealLinearSpace
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/VectorSpace.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/VectorSpace.kt
deleted file mode 100644
index cfacf6826..000000000
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/VectorSpace.kt
+++ /dev/null
@@ -1,72 +0,0 @@
-package space.kscience.kmath.linear
-
-import space.kscience.kmath.operations.Group
-import space.kscience.kmath.operations.RealField
-import space.kscience.kmath.operations.ScaleOperations
-import space.kscience.kmath.operations.invoke
-import space.kscience.kmath.structures.Buffer
-import space.kscience.kmath.structures.BufferFactory
-
-/**
- * A linear space for vectors.
- * Could be used on any point-like structure
- */
-public interface VectorSpace<T : Any, A> : Group<Point<T>>, ScaleOperations<Point<T>>
-        where A : Group<T>, A : ScaleOperations<T> {
-    public val size: Int
-    public val algebra: A
-    override val zero: Point<T> get() = produce { algebra.zero }
-
-    public fun produce(initializer: A.(Int) -> T): Point<T>
-
-    override fun add(a: Point<T>, b: Point<T>): Point<T> = produce { algebra { a[it] + b[it] } }
-
-    override fun scale(a: Point<T>, value: Double): Point<T> = produce { algebra.scale(a[it], value) }
-
-    override fun Point<T>.unaryMinus(): Point<T> = produce { -get(it) }
-
-    //TODO add basis
-
-    public companion object {
-        private val realSpaceCache: MutableMap<Int, BufferVectorSpace<Double, RealField>> = hashMapOf()
-
-        /**
-         * Non-boxing double vector space
-         */
-        public fun real(size: Int): BufferVectorSpace<Double, RealField> = realSpaceCache.getOrPut(size) {
-            BufferVectorSpace(
-                size,
-                RealField,
-                Buffer.Companion::auto
-            )
-        }
-
-        /**
-         * A structured vector space with custom buffer
-         */
-        public fun <T : Any, A> buffered(
-            size: Int,
-            space: A,
-            bufferFactory: BufferFactory<T> = Buffer.Companion::boxing,
-        ): BufferVectorSpace<T, A> where A : Group<T>, A : ScaleOperations<T> =
-            BufferVectorSpace(size, space, bufferFactory)
-
-        /**
-         * Automatic buffered vector, unboxed if it is possible
-         */
-        public inline fun <reified T : Any, A> auto(
-            size: Int,
-            space: A,
-        ): VectorSpace<T, A> where A : Group<T>, A : ScaleOperations<T> =
-            buffered(size, space, Buffer.Companion::auto)
-    }
-}
-
-
-public class BufferVectorSpace<T : Any, A>(
-    override val size: Int,
-    override val algebra: A,
-    public val bufferFactory: BufferFactory<T>,
-) : VectorSpace<T, A> where A : Group<T>, A : ScaleOperations<T> {
-    override fun produce(initializer: A.(Int) -> T): Buffer<T> = bufferFactory(size) { algebra.initializer(it) }
-}
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/VirtualMatrix.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/VirtualMatrix.kt
index 26b1899a1..11699ce2f 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/VirtualMatrix.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/VirtualMatrix.kt
@@ -31,6 +31,4 @@ public class VirtualMatrix<T : Any>(
         result = 31 * result + generator.hashCode()
         return result
     }
-
-
 }
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/NDStructure.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/NDStructure.kt
index 137772632..62e126694 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/NDStructure.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/NDStructure.kt
@@ -74,7 +74,7 @@ public interface NDStructure<T> {
          *
          * Strides should be reused if possible.
          */
-        public fun <T> build(
+        public fun <T> buffered(
             strides: Strides,
             bufferFactory: BufferFactory<T> = Buffer.Companion::boxing,
             initializer: (IntArray) -> T,
@@ -94,11 +94,11 @@ public interface NDStructure<T> {
             crossinline initializer: (IntArray) -> T,
         ): NDBuffer<T> = NDBuffer(strides, Buffer.auto(type, strides.linearSize) { i -> initializer(strides.index(i)) })
 
-        public fun <T> build(
+        public fun <T> buffered(
             shape: IntArray,
             bufferFactory: BufferFactory<T> = Buffer.Companion::boxing,
             initializer: (IntArray) -> T,
-        ): NDBuffer<T> = build(DefaultStrides(shape), bufferFactory, initializer)
+        ): NDBuffer<T> = buffered(DefaultStrides(shape), bufferFactory, initializer)
 
         public inline fun <reified T : Any> auto(
             shape: IntArray,
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/Structure1D.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/Structure1D.kt
index e83485ff0..c54bfeed9 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/Structure1D.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/Structure1D.kt
@@ -46,7 +46,11 @@ private inline class Buffer1DWrapper<T>(val buffer: Buffer<T>) : Structure1D<T>
  * Represent a [NDStructure] as [Structure1D]. Throw error in case of dimension mismatch
  */
 public fun <T> NDStructure<T>.as1D(): Structure1D<T> = if (shape.size == 1) {
-    if (this is NDBuffer) Buffer1DWrapper(this.buffer) else Structure1DWrapper(this)
+    when (this) {
+        is Structure1DWrapper -> this
+        is NDBuffer -> Buffer1DWrapper(this.buffer)
+        else -> Structure1DWrapper(this)
+    }
 } else
     error("Can't create 1d-structure from ${shape.size}d-structure")
 
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/Structure2D.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/Structure2D.kt
index fcc8c0d7e..0098eeb3b 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/Structure2D.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/Structure2D.kt
@@ -1,7 +1,5 @@
 package space.kscience.kmath.nd
 
-import space.kscience.kmath.linear.BufferMatrix
-import space.kscience.kmath.linear.RealMatrixContext
 import space.kscience.kmath.structures.Buffer
 import space.kscience.kmath.structures.VirtualBuffer
 
@@ -54,15 +52,7 @@ public interface Structure2D<T> : NDStructure<T> {
             for (j in 0 until colNum) yield(intArrayOf(i, j) to get(i, j))
     }
 
-    public companion object {
-        public inline fun real(
-            rows: Int,
-            columns: Int,
-            crossinline init: (i: Int, j: Int) -> Double,
-        ): BufferMatrix<Double> = RealMatrixContext.produce(rows,columns) { i, j ->
-            init(i, j)
-        }
-    }
+    public companion object
 }
 
 /**
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/BufferAccessor2D.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/BufferAccessor2D.kt
index fd440a344..d9e37ebd8 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/BufferAccessor2D.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/BufferAccessor2D.kt
@@ -25,7 +25,7 @@ internal class BufferAccessor2D<T : Any>(
     public fun create(mat: Structure2D<T>): MutableBuffer<T> = create { i, j -> mat[i, j] }
 
     //TODO optimize wrapper
-    public fun MutableBuffer<T>.collect(): Structure2D<T> = NDStructure.build(
+    public fun MutableBuffer<T>.collect(): Structure2D<T> = NDStructure.buffered(
         DefaultStrides(intArrayOf(rowNum, colNum)),
         factory
     ) { (i, j) ->
diff --git a/kmath-core/src/commonTest/kotlin/space/kscience/kmath/linear/MatrixTest.kt b/kmath-core/src/commonTest/kotlin/space/kscience/kmath/linear/MatrixTest.kt
index 75967f024..5cf83889a 100644
--- a/kmath-core/src/commonTest/kotlin/space/kscience/kmath/linear/MatrixTest.kt
+++ b/kmath-core/src/commonTest/kotlin/space/kscience/kmath/linear/MatrixTest.kt
@@ -10,7 +10,7 @@ import kotlin.test.assertEquals
 class MatrixTest {
     @Test
     fun testTranspose() {
-        val matrix = MatrixContext.real.one(3, 3)
+        val matrix = LinearSpace.real.one(3, 3)
         val transposed = matrix.transpose()
         assertEquals(matrix, transposed)
     }
@@ -39,7 +39,7 @@ class MatrixTest {
         infix fun Matrix<Double>.pow(power: Int): Matrix<Double> {
             var res = this
             repeat(power - 1) {
-                res = RealMatrixContext.invoke { res dot this@pow }
+                res = RealLinearSpace.invoke { res dot this@pow }
             }
             return res
         }
@@ -52,7 +52,7 @@ class MatrixTest {
         val firstMatrix = NDStructure.auto(2, 3) { (i, j) -> (i + j).toDouble() }.as2D()
         val secondMatrix = NDStructure.auto(3, 2) { (i, j) -> (i + j).toDouble() }.as2D()
 
-        MatrixContext.real.run {
+        LinearSpace.real.run {
 //            val firstMatrix = produce(2, 3) { i, j -> (i + j).toDouble() }
 //            val secondMatrix = produce(3, 2) { i, j -> (i + j).toDouble() }
             val result = firstMatrix dot secondMatrix
diff --git a/kmath-core/src/commonTest/kotlin/space/kscience/kmath/linear/RealLUSolverTest.kt b/kmath-core/src/commonTest/kotlin/space/kscience/kmath/linear/RealLUSolverTest.kt
index f1289801a..4d6b8f5be 100644
--- a/kmath-core/src/commonTest/kotlin/space/kscience/kmath/linear/RealLUSolverTest.kt
+++ b/kmath-core/src/commonTest/kotlin/space/kscience/kmath/linear/RealLUSolverTest.kt
@@ -7,8 +7,8 @@ class RealLUSolverTest {
 
     @Test
     fun testInvertOne() {
-        val matrix = MatrixContext.real.one(2, 2)
-        val inverted = MatrixContext.real.inverseWithLup(matrix)
+        val matrix = LinearSpace.real.one(2, 2)
+        val inverted = LinearSpace.real.inverseWithLup(matrix)
         assertEquals(matrix, inverted)
     }
 
@@ -19,7 +19,7 @@ class RealLUSolverTest {
             1.0, 3.0
         )
 
-        MatrixContext.real.run {
+        LinearSpace.real.run {
             val lup = lup(matrix)
 
             //Check determinant
@@ -36,7 +36,7 @@ class RealLUSolverTest {
             1.0, 3.0
         )
 
-        val inverted = MatrixContext.real.inverseWithLup(matrix)
+        val inverted = LinearSpace.real.inverseWithLup(matrix)
 
         val expected = Matrix.square(
             0.375, -0.125,
diff --git a/kmath-dimensions/src/commonMain/kotlin/space/kscience/kmath/dimensions/Wrappers.kt b/kmath-dimensions/src/commonMain/kotlin/space/kscience/kmath/dimensions/Wrappers.kt
index 237824a39..89ff97f14 100644
--- a/kmath-dimensions/src/commonMain/kotlin/space/kscience/kmath/dimensions/Wrappers.kt
+++ b/kmath-dimensions/src/commonMain/kotlin/space/kscience/kmath/dimensions/Wrappers.kt
@@ -77,7 +77,7 @@ public inline class DPointWrapper<T, D : Dimension>(public val point: Point<T>)
 /**
  * Basic operations on dimension-safe matrices. Operates on [Matrix]
  */
-public inline class DMatrixContext<T : Any>(public val context: MatrixContext<T, Matrix<T>>) {
+public inline class DMatrixContext<T : Any>(public val context: LinearSpace<T, Matrix<T>>) {
     public inline fun <reified R : Dimension, reified C : Dimension> Matrix<T>.coerce(): DMatrix<T, R, C> {
         require(rowNum == Dimension.dim<R>().toInt()) {
             "Row number mismatch: expected ${Dimension.dim<R>()} but found $rowNum"
@@ -96,14 +96,14 @@ public inline class DMatrixContext<T : Any>(public val context: MatrixContext<T,
     public inline fun <reified R : Dimension, reified C : Dimension> produce(noinline initializer: (i: Int, j: Int) -> T): DMatrix<T, R, C> {
         val rows = Dimension.dim<R>()
         val cols = Dimension.dim<C>()
-        return context.produce(rows.toInt(), cols.toInt(), initializer).coerce<R, C>()
+        return context.buildMatrix(rows.toInt(), cols.toInt(), initializer).coerce<R, C>()
     }
 
     public inline fun <reified D : Dimension> point(noinline initializer: (Int) -> T): DPoint<T, D> {
         val size = Dimension.dim<D>()
 
         return DPoint.coerceUnsafe(
-            context.point(
+            context.buildVector(
                 size.toInt(),
                 initializer
             )
@@ -136,7 +136,7 @@ public inline class DMatrixContext<T : Any>(public val context: MatrixContext<T,
         context { (this@transpose as Matrix<T>).transpose() }.coerce()
 
     public companion object {
-        public val real: DMatrixContext<Double> = DMatrixContext(MatrixContext.real)
+        public val real: DMatrixContext<Double> = DMatrixContext(LinearSpace.real)
     }
 }
 
diff --git a/kmath-ejml/src/main/kotlin/space/kscience/kmath/ejml/EjmlMatrixContext.kt b/kmath-ejml/src/main/kotlin/space/kscience/kmath/ejml/EjmlLinearSpace.kt
similarity index 80%
rename from kmath-ejml/src/main/kotlin/space/kscience/kmath/ejml/EjmlMatrixContext.kt
rename to kmath-ejml/src/main/kotlin/space/kscience/kmath/ejml/EjmlLinearSpace.kt
index 95c465975..c3f93ca55 100644
--- a/kmath-ejml/src/main/kotlin/space/kscience/kmath/ejml/EjmlMatrixContext.kt
+++ b/kmath-ejml/src/main/kotlin/space/kscience/kmath/ejml/EjmlLinearSpace.kt
@@ -11,7 +11,7 @@ import space.kscience.kmath.operations.ScaleOperations
  *
  * @author Iaroslav Postovalov
  */
-public object EjmlMatrixContext : MatrixContext<Double, EjmlMatrix>, ScaleOperations<Matrix<Double>> {
+public object EjmlLinearSpace : LinearSpace<Double, EjmlMatrix>, ScaleOperations<Matrix<Double>> {
 
     /**
      * Converts this matrix to EJML one.
@@ -19,7 +19,7 @@ public object EjmlMatrixContext : MatrixContext<Double, EjmlMatrix>, ScaleOperat
     @OptIn(UnstableKMathAPI::class)
     public fun Matrix<Double>.toEjml(): EjmlMatrix = when (val matrix = origin) {
         is EjmlMatrix -> matrix
-        else -> produce(rowNum, colNum) { i, j -> get(i, j) }
+        else -> buildMatrix(rowNum, colNum) { i, j -> get(i, j) }
     }
 
     /**
@@ -30,14 +30,14 @@ public object EjmlMatrixContext : MatrixContext<Double, EjmlMatrix>, ScaleOperat
             (0 until it.numRows()).forEach { row -> it[row, 0] = get(row) }
         })
 
-    override fun produce(rows: Int, columns: Int, initializer: (i: Int, j: Int) -> Double): EjmlMatrix =
+    override fun buildMatrix(rows: Int, columns: Int, initializer: (i: Int, j: Int) -> Double): EjmlMatrix =
         EjmlMatrix(SimpleMatrix(rows, columns).also {
             (0 until rows).forEach { row ->
                 (0 until columns).forEach { col -> it[row, col] = initializer(row, col) }
             }
         })
 
-    override fun point(size: Int, initializer: (Int) -> Double): Point<Double> =
+    override fun buildVector(size: Int, initializer: (Int) -> Double): Point<Double> =
         EjmlVector(SimpleMatrix(size, 1).also {
             (0 until it.numRows()).forEach { row -> it[row, 0] = initializer(row) }
         })
@@ -58,7 +58,7 @@ public object EjmlMatrixContext : MatrixContext<Double, EjmlMatrix>, ScaleOperat
         EjmlMatrix(toEjml().origin - b.toEjml().origin)
 
     public override fun scale(a: Matrix<Double>, value: Double): EjmlMatrix =
-        produce(a.rowNum, a.colNum) { i, j -> a[i, j] * value }
+        buildMatrix(a.rowNum, a.colNum) { i, j -> a[i, j] * value }
 
     public override operator fun Matrix<Double>.times(value: Double): EjmlMatrix =
         EjmlMatrix(toEjml().origin.scale(value))
@@ -72,7 +72,7 @@ public object EjmlMatrixContext : MatrixContext<Double, EjmlMatrix>, ScaleOperat
  * @return the solution for 'x' that is n by p.
  * @author Iaroslav Postovalov
  */
-public fun EjmlMatrixContext.solve(a: Matrix<Double>, b: Matrix<Double>): EjmlMatrix =
+public fun EjmlLinearSpace.solve(a: Matrix<Double>, b: Matrix<Double>): EjmlMatrix =
     EjmlMatrix(a.toEjml().origin.solve(b.toEjml().origin))
 
 /**
@@ -83,10 +83,10 @@ public fun EjmlMatrixContext.solve(a: Matrix<Double>, b: Matrix<Double>): EjmlMa
  * @return the solution for 'x' that is n by p.
  * @author Iaroslav Postovalov
  */
-public fun EjmlMatrixContext.solve(a: Matrix<Double>, b: Point<Double>): EjmlVector =
+public fun EjmlLinearSpace.solve(a: Matrix<Double>, b: Point<Double>): EjmlVector =
     EjmlVector(a.toEjml().origin.solve(b.toEjml().origin))
 
 @OptIn(UnstableKMathAPI::class)
 public fun EjmlMatrix.inverted(): EjmlMatrix = getFeature<InverseMatrixFeature<Double>>()!!.inverse as EjmlMatrix
 
-public fun EjmlMatrixContext.inverse(matrix: Matrix<Double>): Matrix<Double> = matrix.toEjml().inverted()
\ No newline at end of file
+public fun EjmlLinearSpace.inverse(matrix: Matrix<Double>): Matrix<Double> = matrix.toEjml().inverted()
\ No newline at end of file
diff --git a/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/RealMatrix.kt b/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/RealMatrix.kt
index 30d002498..b93c430f9 100644
--- a/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/RealMatrix.kt
+++ b/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/RealMatrix.kt
@@ -22,14 +22,14 @@ import kotlin.math.pow
 public typealias RealMatrix = Matrix<Double>
 
 public fun realMatrix(rowNum: Int, colNum: Int, initializer: (i: Int, j: Int) -> Double): RealMatrix =
-    MatrixContext.real.produce(rowNum, colNum, initializer)
+    LinearSpace.real.buildMatrix(rowNum, colNum, initializer)
 
 public fun Array<DoubleArray>.toMatrix(): RealMatrix {
-    return MatrixContext.real.produce(size, this[0].size) { row, col -> this[row][col] }
+    return LinearSpace.real.buildMatrix(size, this[0].size) { row, col -> this[row][col] }
 }
 
 public fun Sequence<DoubleArray>.toMatrix(): RealMatrix = toList().let {
-    MatrixContext.real.produce(it.size, it[0].size) { row, col -> it[row][col] }
+    LinearSpace.real.buildMatrix(it.size, it[0].size) { row, col -> it[row][col] }
 }
 
 public fun RealMatrix.repeatStackVertical(n: Int): RealMatrix =
@@ -42,37 +42,37 @@ public fun RealMatrix.repeatStackVertical(n: Int): RealMatrix =
  */
 
 public operator fun RealMatrix.times(double: Double): RealMatrix =
-    MatrixContext.real.produce(rowNum, colNum) { row, col ->
+    LinearSpace.real.buildMatrix(rowNum, colNum) { row, col ->
         this[row, col] * double
     }
 
 public operator fun RealMatrix.plus(double: Double): RealMatrix =
-    MatrixContext.real.produce(rowNum, colNum) { row, col ->
+    LinearSpace.real.buildMatrix(rowNum, colNum) { row, col ->
         this[row, col] + double
     }
 
 public operator fun RealMatrix.minus(double: Double): RealMatrix =
-    MatrixContext.real.produce(rowNum, colNum) { row, col ->
+    LinearSpace.real.buildMatrix(rowNum, colNum) { row, col ->
         this[row, col] - double
     }
 
 public operator fun RealMatrix.div(double: Double): RealMatrix =
-    MatrixContext.real.produce(rowNum, colNum) { row, col ->
+    LinearSpace.real.buildMatrix(rowNum, colNum) { row, col ->
         this[row, col] / double
     }
 
 public operator fun Double.times(matrix: RealMatrix): RealMatrix =
-    MatrixContext.real.produce(matrix.rowNum, matrix.colNum) { row, col ->
+    LinearSpace.real.buildMatrix(matrix.rowNum, matrix.colNum) { row, col ->
         this * matrix[row, col]
     }
 
 public operator fun Double.plus(matrix: RealMatrix): RealMatrix =
-    MatrixContext.real.produce(matrix.rowNum, matrix.colNum) { row, col ->
+    LinearSpace.real.buildMatrix(matrix.rowNum, matrix.colNum) { row, col ->
         this + matrix[row, col]
     }
 
 public operator fun Double.minus(matrix: RealMatrix): RealMatrix =
-    MatrixContext.real.produce(matrix.rowNum, matrix.colNum) { row, col ->
+    LinearSpace.real.buildMatrix(matrix.rowNum, matrix.colNum) { row, col ->
         this - matrix[row, col]
     }
 
@@ -87,20 +87,20 @@ public operator fun Double.minus(matrix: RealMatrix): RealMatrix =
 
 @UnstableKMathAPI
 public operator fun RealMatrix.times(other: RealMatrix): RealMatrix =
-    MatrixContext.real.produce(rowNum, colNum) { row, col -> this[row, col] * other[row, col] }
+    LinearSpace.real.buildMatrix(rowNum, colNum) { row, col -> this[row, col] * other[row, col] }
 
 public operator fun RealMatrix.plus(other: RealMatrix): RealMatrix =
-    MatrixContext.real.add(this, other)
+    LinearSpace.real.add(this, other)
 
 public operator fun RealMatrix.minus(other: RealMatrix): RealMatrix =
-    MatrixContext.real.produce(rowNum, colNum) { row, col -> this[row, col] - other[row, col] }
+    LinearSpace.real.buildMatrix(rowNum, colNum) { row, col -> this[row, col] - other[row, col] }
 
 /*
  *  Operations on columns
  */
 
 public inline fun RealMatrix.appendColumn(crossinline mapper: (Buffer<Double>) -> Double): RealMatrix =
-    MatrixContext.real.produce(rowNum, colNum + 1) { row, col ->
+    LinearSpace.real.buildMatrix(rowNum, colNum + 1) { row, col ->
         if (col < colNum)
             this[row, col]
         else
@@ -108,7 +108,7 @@ public inline fun RealMatrix.appendColumn(crossinline mapper: (Buffer<Double>) -
     }
 
 public fun RealMatrix.extractColumns(columnRange: IntRange): RealMatrix =
-    MatrixContext.real.produce(rowNum, columnRange.count()) { row, col ->
+    LinearSpace.real.buildMatrix(rowNum, columnRange.count()) { row, col ->
         this[row, columnRange.first + col]
     }
 
@@ -141,14 +141,14 @@ public fun RealMatrix.max(): Double? = elements().map { (_, value) -> value }.ma
 public fun RealMatrix.average(): Double = elements().map { (_, value) -> value }.average()
 
 public inline fun RealMatrix.map(crossinline transform: (Double) -> Double): RealMatrix =
-    MatrixContext.real.produce(rowNum, colNum) { i, j ->
+    LinearSpace.real.buildMatrix(rowNum, colNum) { i, j ->
         transform(get(i, j))
     }
 
 /**
  * Inverse a square real matrix using LUP decomposition
  */
-public fun RealMatrix.inverseWithLup(): RealMatrix = MatrixContext.real.inverseWithLup(this)
+public fun RealMatrix.inverseWithLup(): RealMatrix = LinearSpace.real.inverseWithLup(this)
 
 //extended operations
 
diff --git a/kmath-for-real/src/commonTest/kotlin/kaceince/kmath/real/RealVectorTest.kt b/kmath-for-real/src/commonTest/kotlin/kaceince/kmath/real/RealVectorTest.kt
index 463c68681..5d032de67 100644
--- a/kmath-for-real/src/commonTest/kotlin/kaceince/kmath/real/RealVectorTest.kt
+++ b/kmath-for-real/src/commonTest/kotlin/kaceince/kmath/real/RealVectorTest.kt
@@ -1,6 +1,6 @@
 package kaceince.kmath.real
 
-import space.kscience.kmath.linear.MatrixContext
+import space.kscience.kmath.linear.LinearSpace
 import space.kscience.kmath.linear.asMatrix
 import space.kscience.kmath.linear.real
 import space.kscience.kmath.linear.transpose
@@ -32,7 +32,7 @@ internal class RealVectorTest {
         val vector2 =  Buffer.real(5) { 5 - it.toDouble() }
         val matrix1 = vector1.asMatrix()
         val matrix2 = vector2.asMatrix().transpose()
-        val product = MatrixContext.real { matrix1 dot matrix2 }
+        val product = LinearSpace.real { matrix1 dot matrix2 }
         assertEquals(5.0, product[1, 0])
         assertEquals(6.0, product[2, 2])
     }
-- 
2.34.1


From 19d3998c3b4c636692a1690c27cb46b40169f50c Mon Sep 17 00:00:00 2001
From: Alexander Nozik <altavir@gmail.com>
Date: Sat, 13 Mar 2021 10:10:00 +0300
Subject: [PATCH 22/37] WIP vector space refactor

---
 .../kscience/kmath/commons/linear/CMMatrix.kt |  80 ++++++---
 .../kscience/kmath/linear/LinearSpace.kt      |  12 +-
 .../kscience/kmath/linear/MatrixBuilder.kt    |   2 +-
 .../kscience/kmath/linear/RealLinearSpace.kt  | 156 +++++++++---------
 .../space/kscience/kmath/nd/NDStructure.kt    |   2 +-
 .../kscience/kmath/ejml/EjmlLinearSpace.kt    |  62 +++++--
 .../space/kscience/kmath/ejml/EjmlMatrix.kt   |   2 +-
 7 files changed, 185 insertions(+), 131 deletions(-)

diff --git 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
index 53f96626d..c1c3d716a 100644
--- 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
@@ -3,12 +3,13 @@ package space.kscience.kmath.commons.linear
 import org.apache.commons.math3.linear.*
 import space.kscience.kmath.linear.*
 import space.kscience.kmath.misc.UnstableKMathAPI
+import space.kscience.kmath.nd.NDStructure
 import space.kscience.kmath.operations.RealField
 import space.kscience.kmath.structures.RealBuffer
 import kotlin.reflect.KClass
 import kotlin.reflect.cast
 
-public inline class CMMatrix(public val origin: RealMatrix) : Matrix<Double> {
+public class CMMatrix(public val origin: RealMatrix) : Matrix<Double> {
     public override val rowNum: Int get() = origin.rowDimension
     public override val colNum: Int get() = origin.columnDimension
 
@@ -51,12 +52,17 @@ public inline class CMMatrix(public val origin: RealMatrix) : Matrix<Double> {
     }?.let(type::cast)
 
     public override operator fun get(i: Int, j: Int): Double = origin.getEntry(i, j)
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other !is NDStructure<*>) return false
+        return NDStructure.contentEquals(this, other)
+    }
+
+    override fun hashCode(): Int = origin.hashCode()
 }
 
-
-public fun RealMatrix.asMatrix(): CMMatrix = CMMatrix(this)
-
-public class CMVector(public val origin: RealVector) : Vector<Double> {
+public inline class CMVector(public val origin: RealVector) : Vector<Double> {
     public override val size: Int get() = origin.dimension
 
     public override operator fun get(index: Int): Double = origin.getEntry(index)
@@ -64,16 +70,17 @@ public class CMVector(public val origin: RealVector) : Vector<Double> {
     public override operator fun iterator(): Iterator<Double> = origin.toArray().iterator()
 }
 
-public fun Point<Double>.toCM(): CMVector = if (this is CMVector) this else {
-    val array = DoubleArray(size) { this[it] }
-    CMVector(ArrayRealVector(array))
-}
-
 public fun RealVector.toPoint(): CMVector = CMVector(this)
 
 public object CMLinearSpace : LinearSpace<Double, RealField> {
-    public override fun buildMatrix(rows: Int, columns: Int, initializer: (i: Int, j: Int) -> Double): CMMatrix {
-        val array = Array(rows) { i -> DoubleArray(columns) { j -> initializer(i, j) } }
+    override val elementAlgebra: RealField get() = RealField
+
+    public override fun buildMatrix(
+        rows: Int,
+        columns: Int,
+        initializer: RealField.(i: Int, j: Int) -> Double,
+    ): CMMatrix {
+        val array = Array(rows) { i -> DoubleArray(columns) { j -> RealField.initializer(i, j) } }
         return CMMatrix(Array2DRowRealMatrix(array))
     }
 
@@ -83,31 +90,50 @@ public object CMLinearSpace : LinearSpace<Double, RealField> {
         else -> {
             //TODO add feature analysis
             val array = Array(rowNum) { i -> DoubleArray(colNum) { j -> get(i, j) } }
-            CMMatrix(Array2DRowRealMatrix(array))
+            Array2DRowRealMatrix(array).wrap()
         }
     }
 
+    public fun Vector<Double>.toCM(): CMVector = if (this is CMVector) this else {
+        val array = DoubleArray(size) { this[it] }
+        ArrayRealVector(array).wrap()
+    }
+
+    private fun RealMatrix.wrap(): CMMatrix = CMMatrix(this)
+    private fun RealVector.wrap(): CMVector = CMVector(this)
+
+    override fun buildVector(size: Int, initializer: RealField.(Int) -> Double): Vector<Double> =
+        ArrayRealVector(DoubleArray(size) { RealField.initializer(it) }).wrap()
+
+    override fun Matrix<Double>.plus(other: Matrix<Double>): CMMatrix =
+        toCM().origin.add(other.toCM().origin).wrap()
+
+    override fun Vector<Double>.plus(other: Vector<Double>): CMVector =
+        toCM().origin.add(other.toCM().origin).wrap()
+
+    override fun Vector<Double>.minus(other: Vector<Double>): CMVector =
+        toCM().origin.subtract(other.toCM().origin).wrap()
 
     public override fun Matrix<Double>.dot(other: Matrix<Double>): CMMatrix =
-        CMMatrix(toCM().origin.multiply(other.toCM().origin))
+        toCM().origin.multiply(other.toCM().origin).wrap()
 
     public override fun Matrix<Double>.dot(vector: Vector<Double>): CMVector =
-        CMVector(toCM().origin.preMultiply(vector.toCM().origin))
+        toCM().origin.preMultiply(vector.toCM().origin).wrap()
 
-    public override operator fun Matrix<Double>.unaryMinus(): CMMatrix =
-        buildMatrix(rowNum, colNum) { i, j -> -get(i, j) }
-
-    public override fun add(a: Matrix<Double>, b: Matrix<Double>): CMMatrix =
-        CMMatrix(a.toCM().origin.multiply(b.toCM().origin))
-
-    public override operator fun Matrix<Double>.minus(b: Matrix<Double>): CMMatrix =
-        CMMatrix(toCM().origin.subtract(b.toCM().origin))
-
-//    public override fun multiply(a: Matrix<Double>, k: Number): CMMatrix =
-//        CMMatrix(a.toCM().origin.scalarMultiply(k.toDouble()))
+    public override operator fun Matrix<Double>.minus(other: Matrix<Double>): CMMatrix =
+        toCM().origin.subtract(other.toCM().origin).wrap()
 
     public override operator fun Matrix<Double>.times(value: Double): CMMatrix =
-        buildMatrix(rowNum, colNum) { i, j -> get(i, j) * value }
+        toCM().origin.scalarMultiply(value).wrap()
+
+    override fun Double.times(m: Matrix<Double>): CMMatrix =
+        m * this
+
+    override fun Vector<Double>.times(value: Double): CMVector =
+        toCM().origin.mapMultiply(value).wrap()
+
+    override fun Double.times(v: Vector<Double>): CMVector =
+        v * this
 }
 
 public operator fun CMMatrix.plus(other: CMMatrix): CMMatrix =
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpace.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpace.kt
index e0076cda9..5800bdd0d 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpace.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpace.kt
@@ -14,12 +14,7 @@ import kotlin.reflect.KClass
  */
 public typealias Matrix<T> = Structure2D<T>
 
-/**
- * Alias for [Structure1D] with more familiar name.
- *
- * @param T the type of items.
- */
-public typealias Vector<T> = Structure1D<T>
+public typealias Vector<T> = Point<T>
 
 /**
  * Basic operations on matrices and vectors. Operates on [Matrix].
@@ -183,12 +178,13 @@ public interface LinearSpace<T : Any, A : Ring<T>> {
             override fun buildMatrix(
                 rows: Int, columns: Int,
                 initializer: A.(i: Int, j: Int) -> T,
-            ): Matrix<T> = NDStructure.buffered(intArrayOf(rows, columns)) { (i, j) ->
+            ): Matrix<T> = NDStructure.buffered(intArrayOf(rows, columns), bufferFactory) { (i, j) ->
                 algebra.initializer(i, j)
             }.as2D()
-
         }
 
+        public val real: LinearSpace<Double, RealField> = buffered(RealField, Buffer.Companion::real)
+
         /**
          * Automatic buffered matrix, unboxed if it is possible
          */
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixBuilder.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixBuilder.kt
index 57bea5cb6..28df78dad 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixBuilder.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixBuilder.kt
@@ -12,7 +12,7 @@ public fun <T : Any> LinearSpace<T, Ring<T>>.matrix(rows: Int, columns: Int, var
 
 @UnstableKMathAPI
 public fun <T : Any> LinearSpace<T, Ring<T>>.vector(vararg elements: T): Vector<T> {
-    return buildVector(elements.size, elements::get)
+    return buildVector(elements.size) { elements[it] }
 }
 
 public inline fun <T : Any> LinearSpace<T, Ring<T>>.row(
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/RealLinearSpace.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/RealLinearSpace.kt
index 6dc97c51e..3fa23db82 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/RealLinearSpace.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/RealLinearSpace.kt
@@ -1,88 +1,86 @@
 package space.kscience.kmath.linear
 
-import space.kscience.kmath.operations.RealField
-import space.kscience.kmath.operations.ScaleOperations
-import space.kscience.kmath.structures.RealBuffer
-
-public object RealLinearSpace : LinearSpace<Double, RealField>, ScaleOperations<Matrix<Double>> {
-
-    override val elementAlgebra: RealField get() = RealField
-
-    public override fun buildMatrix(
-        rows: Int,
-        columns: Int,
-        initializer: (i: Int, j: Int) -> Double,
-    ): Matrix<Double> {
-        val buffer = RealBuffer(rows * columns) { offset -> initializer(offset / columns, offset % columns) }
-        return  BufferMatrix(rows, columns, buffer)
-    }
-
-    public fun Matrix<Double>.toBufferMatrix(): BufferMatrix<Double> = if (this is BufferMatrix) this else {
-        buildMatrix(rowNum, colNum) { i, j -> get(i, j) }
-    }
-
-    public fun one(rows: Int, columns: Int): Matrix<Double> = VirtualMatrix(rows, columns) { i, j ->
-        if (i == j) 1.0 else 0.0
-    } + DiagonalFeature
-
-    override fun Matrix<Double>.unaryMinus(): Matrix<Double> = buildMatrix(rowNum, colNum) { i, j -> -get(i, j) }
-
-    public override infix fun Matrix<Double>.dot(other: Matrix<Double>): BufferMatrix<Double> {
-        require(colNum == other.rowNum) { "Matrix dot operation dimension mismatch: ($rowNum, $colNum) x (${other.rowNum}, ${other.colNum})" }
-        val bufferMatrix = toBufferMatrix()
-        val otherBufferMatrix = other.toBufferMatrix()
-        return buildMatrix(rowNum, other.colNum) { i, j ->
-            var res = 0.0
-            for (l in 0 until colNum) {
-                res += bufferMatrix[i, l] * otherBufferMatrix[l, j]
-            }
-            res
-        }
-    }
-
-    public override infix fun Matrix<Double>.dot(vector: Point<Double>): Point<Double> {
-        require(colNum == vector.size) { "Matrix dot vector operation dimension mismatch: ($rowNum, $colNum) x (${vector.size})" }
-        val bufferMatrix = toBufferMatrix()
-        return RealBuffer(rowNum) { i ->
-            var res = 0.0
-            for (j in 0 until colNum) {
-                res += bufferMatrix[i, j] * vector[j]
-            }
-            res
-        }
-    }
-
-    override fun add(a: Matrix<Double>, b: Matrix<Double>): BufferMatrix<Double> {
-        require(a.rowNum == b.rowNum) { "Row number mismatch in matrix addition. Left side: ${a.rowNum}, right side: ${b.rowNum}" }
-        require(a.colNum == b.colNum) { "Column number mismatch in matrix addition. Left side: ${a.colNum}, right side: ${b.colNum}" }
-        val aBufferMatrix = a.toBufferMatrix()
-        val bBufferMatrix = b.toBufferMatrix()
-        return buildMatrix(a.rowNum, a.colNum) { i, j ->
-            aBufferMatrix[i, j] + bBufferMatrix[i, j]
-        }
-    }
-
-    override fun scale(a: Matrix<Double>, value: Double): BufferMatrix<Double> {
-        val bufferMatrix = a.toBufferMatrix()
-        return buildMatrix(a.rowNum, a.colNum) { i, j -> bufferMatrix[i, j] * value }
-    }
-
-    override fun Matrix<Double>.times(value: Double): BufferMatrix<Double> = scale(this, value)
+//public object RealLinearSpace:
 
+//public object RealLinearSpace : LinearSpace<Double, RealField>, ScaleOperations<Matrix<Double>> {
 //
-//    override fun multiply(a: Matrix<Double>, k: Number): BufferMatrix<Double> {
-//        val aBufferMatrix = a.toBufferMatrix()
-//        return produce(a.rowNum, a.colNum) { i, j -> aBufferMatrix[i, j] * k.toDouble() }
+//    override val elementAlgebra: RealField get() = RealField
+//
+//    public override fun buildMatrix(
+//        rows: Int,
+//        columns: Int,
+//        initializer: (i: Int, j: Int) -> Double,
+//    ): Matrix<Double> {
+//        val buffer = RealBuffer(rows * columns) { offset -> initializer(offset / columns, offset % columns) }
+//        return  BufferMatrix(rows, columns, buffer)
 //    }
 //
-//    override fun divide(a: Matrix<Double>, k: Number): BufferMatrix<Double> {
-//        val aBufferMatrix = a.toBufferMatrix()
-//        return produce(a.rowNum, a.colNum) { i, j -> aBufferMatrix[i, j] / k.toDouble() }
+//    public fun Matrix<Double>.toBufferMatrix(): BufferMatrix<Double> = if (this is BufferMatrix) this else {
+//        buildMatrix(rowNum, colNum) { i, j -> get(i, j) }
 //    }
-}
+//
+//    public fun one(rows: Int, columns: Int): Matrix<Double> = VirtualMatrix(rows, columns) { i, j ->
+//        if (i == j) 1.0 else 0.0
+//    } + DiagonalFeature
+//
+//    override fun Matrix<Double>.unaryMinus(): Matrix<Double> = buildMatrix(rowNum, colNum) { i, j -> -get(i, j) }
+//
+//    public override infix fun Matrix<Double>.dot(other: Matrix<Double>): BufferMatrix<Double> {
+//        require(colNum == other.rowNum) { "Matrix dot operation dimension mismatch: ($rowNum, $colNum) x (${other.rowNum}, ${other.colNum})" }
+//        val bufferMatrix = toBufferMatrix()
+//        val otherBufferMatrix = other.toBufferMatrix()
+//        return buildMatrix(rowNum, other.colNum) { i, j ->
+//            var res = 0.0
+//            for (l in 0 until colNum) {
+//                res += bufferMatrix[i, l] * otherBufferMatrix[l, j]
+//            }
+//            res
+//        }
+//    }
+//
+//    public override infix fun Matrix<Double>.dot(vector: Point<Double>): Point<Double> {
+//        require(colNum == vector.size) { "Matrix dot vector operation dimension mismatch: ($rowNum, $colNum) x (${vector.size})" }
+//        val bufferMatrix = toBufferMatrix()
+//        return RealBuffer(rowNum) { i ->
+//            var res = 0.0
+//            for (j in 0 until colNum) {
+//                res += bufferMatrix[i, j] * vector[j]
+//            }
+//            res
+//        }
+//    }
+//
+//    override fun add(a: Matrix<Double>, b: Matrix<Double>): BufferMatrix<Double> {
+//        require(a.rowNum == b.rowNum) { "Row number mismatch in matrix addition. Left side: ${a.rowNum}, right side: ${b.rowNum}" }
+//        require(a.colNum == b.colNum) { "Column number mismatch in matrix addition. Left side: ${a.colNum}, right side: ${b.colNum}" }
+//        val aBufferMatrix = a.toBufferMatrix()
+//        val bBufferMatrix = b.toBufferMatrix()
+//        return buildMatrix(a.rowNum, a.colNum) { i, j ->
+//            aBufferMatrix[i, j] + bBufferMatrix[i, j]
+//        }
+//    }
+//
+//    override fun scale(a: Matrix<Double>, value: Double): BufferMatrix<Double> {
+//        val bufferMatrix = a.toBufferMatrix()
+//        return buildMatrix(a.rowNum, a.colNum) { i, j -> bufferMatrix[i, j] * value }
+//    }
+//
+//    override fun Matrix<Double>.times(value: Double): BufferMatrix<Double> = scale(this, value)
+//
+////
+////    override fun multiply(a: Matrix<Double>, k: Number): BufferMatrix<Double> {
+////        val aBufferMatrix = a.toBufferMatrix()
+////        return produce(a.rowNum, a.colNum) { i, j -> aBufferMatrix[i, j] * k.toDouble() }
+////    }
+////
+////    override fun divide(a: Matrix<Double>, k: Number): BufferMatrix<Double> {
+////        val aBufferMatrix = a.toBufferMatrix()
+////        return produce(a.rowNum, a.colNum) { i, j -> aBufferMatrix[i, j] / k.toDouble() }
+////    }
+//}
 
 
-/**
- * Partially optimized real-valued matrix
- */
-public val LinearSpace.Companion.real: RealLinearSpace get() = RealLinearSpace
+///**
+// * Partially optimized real-valued matrix
+// */
+//public val LinearSpace.Companion.real: RealLinearSpace get() = RealLinearSpace
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/NDStructure.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/NDStructure.kt
index 62e126694..48041df58 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/NDStructure.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/NDStructure.kt
@@ -52,7 +52,7 @@ public interface NDStructure<T> {
      * optimize operations and performance. If the feature is not present, null is defined.
      */
     @UnstableKMathAPI
-    public fun <T : Any> getFeature(type: KClass<T>): T? = null
+    public fun <F : Any> getFeature(type: KClass<F>): F? = null
 
     public companion object {
         /**
diff --git a/kmath-ejml/src/main/kotlin/space/kscience/kmath/ejml/EjmlLinearSpace.kt b/kmath-ejml/src/main/kotlin/space/kscience/kmath/ejml/EjmlLinearSpace.kt
index c3f93ca55..339e06459 100644
--- a/kmath-ejml/src/main/kotlin/space/kscience/kmath/ejml/EjmlLinearSpace.kt
+++ b/kmath-ejml/src/main/kotlin/space/kscience/kmath/ejml/EjmlLinearSpace.kt
@@ -4,6 +4,7 @@ import org.ejml.simple.SimpleMatrix
 import space.kscience.kmath.linear.*
 import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.nd.getFeature
+import space.kscience.kmath.operations.RealField
 import space.kscience.kmath.operations.ScaleOperations
 
 /**
@@ -11,7 +12,9 @@ import space.kscience.kmath.operations.ScaleOperations
  *
  * @author Iaroslav Postovalov
  */
-public object EjmlLinearSpace : LinearSpace<Double, EjmlMatrix>, ScaleOperations<Matrix<Double>> {
+public object EjmlLinearSpace : LinearSpace<Double, RealField>, ScaleOperations<Matrix<Double>> {
+
+    override val elementAlgebra: RealField get() = RealField
 
     /**
      * Converts this matrix to EJML one.
@@ -25,43 +28,74 @@ public object EjmlLinearSpace : LinearSpace<Double, EjmlMatrix>, ScaleOperations
     /**
      * Converts this vector to EJML one.
      */
-    public fun Point<Double>.toEjml(): EjmlVector =
-        if (this is EjmlVector) this else EjmlVector(SimpleMatrix(size, 1).also {
+    public fun Vector<Double>.toEjml(): EjmlVector = when (this) {
+        is EjmlVector -> this
+        else -> EjmlVector(SimpleMatrix(size, 1).also {
             (0 until it.numRows()).forEach { row -> it[row, 0] = get(row) }
         })
+    }
 
-    override fun buildMatrix(rows: Int, columns: Int, initializer: (i: Int, j: Int) -> Double): EjmlMatrix =
+    override fun buildMatrix(rows: Int, columns: Int, initializer: RealField.(i: Int, j: Int) -> Double): EjmlMatrix =
         EjmlMatrix(SimpleMatrix(rows, columns).also {
             (0 until rows).forEach { row ->
-                (0 until columns).forEach { col -> it[row, col] = initializer(row, col) }
+                (0 until columns).forEach { col -> it[row, col] = RealField.initializer(row, col) }
             }
         })
 
-    override fun buildVector(size: Int, initializer: (Int) -> Double): Point<Double> =
+    override fun buildVector(size: Int, initializer: RealField.(Int) -> Double): Vector<Double> =
         EjmlVector(SimpleMatrix(size, 1).also {
             (0 until it.numRows()).forEach { row -> it[row, 0] = initializer(row) }
         })
 
+    private fun SimpleMatrix.wrapMatrix() = EjmlMatrix(this)
+    private fun SimpleMatrix.wrapVector() = EjmlVector(this)
 
-    override fun Matrix<Double>.unaryMinus(): Matrix<Double>  = this*(-1)
+    override fun Matrix<Double>.unaryMinus(): Matrix<Double> = this * (-1)
 
     public override fun Matrix<Double>.dot(other: Matrix<Double>): EjmlMatrix =
         EjmlMatrix(toEjml().origin.mult(other.toEjml().origin))
 
-    public override fun Matrix<Double>.dot(vector: Point<Double>): EjmlVector =
+    public override fun Matrix<Double>.dot(vector: Vector<Double>): EjmlVector =
         EjmlVector(toEjml().origin.mult(vector.toEjml().origin))
 
-    public override fun add(a: Matrix<Double>, b: Matrix<Double>): EjmlMatrix =
-        EjmlMatrix(a.toEjml().origin + b.toEjml().origin)
-
-    public override operator fun Matrix<Double>.minus(b: Matrix<Double>): EjmlMatrix =
-        EjmlMatrix(toEjml().origin - b.toEjml().origin)
+    public override operator fun Matrix<Double>.minus(other: Matrix<Double>): EjmlMatrix =
+        EjmlMatrix(toEjml().origin - other.toEjml().origin)
 
     public override fun scale(a: Matrix<Double>, value: Double): EjmlMatrix =
-        buildMatrix(a.rowNum, a.colNum) { i, j -> a[i, j] * value }
+        a.toEjml().origin.scale(value).wrapMatrix()
 
     public override operator fun Matrix<Double>.times(value: Double): EjmlMatrix =
         EjmlMatrix(toEjml().origin.scale(value))
+
+    override fun Vector<Double>.unaryMinus(): EjmlVector =
+        toEjml().origin.negative().wrapVector()
+
+    override fun Matrix<Double>.plus(other: Matrix<Double>): Matrix<Double> {
+        TODO("Not yet implemented")
+    }
+
+    override fun Vector<Double>.plus(other: Vector<Double>): Vector<Double> {
+        TODO("Not yet implemented")
+    }
+
+    override fun Vector<Double>.minus(other: Vector<Double>): Vector<Double> {
+        TODO("Not yet implemented")
+    }
+
+    override fun Double.times(m: Matrix<Double>): Matrix<Double> {
+        TODO("Not yet implemented")
+    }
+
+    override fun Vector<Double>.times(value: Double): Vector<Double> {
+        TODO("Not yet implemented")
+    }
+
+    override fun Double.times(v: Vector<Double>): Vector<Double> {
+        TODO("Not yet implemented")
+    }
+
+    public override fun add(a: Matrix<Double>, b: Matrix<Double>): EjmlMatrix =
+        EjmlMatrix(a.toEjml().origin + b.toEjml().origin)
 }
 
 /**
diff --git a/kmath-ejml/src/main/kotlin/space/kscience/kmath/ejml/EjmlMatrix.kt b/kmath-ejml/src/main/kotlin/space/kscience/kmath/ejml/EjmlMatrix.kt
index d23e613e4..a1984fa31 100644
--- a/kmath-ejml/src/main/kotlin/space/kscience/kmath/ejml/EjmlMatrix.kt
+++ b/kmath-ejml/src/main/kotlin/space/kscience/kmath/ejml/EjmlMatrix.kt
@@ -85,7 +85,7 @@ public class EjmlMatrix(public val origin: SimpleMatrix) : Matrix<Double> {
 
     override fun equals(other: Any?): Boolean {
         if (this === other) return true
-        if (other !is Matrix<*>) return false
+        if (other !is NDStructure<*>) return false
         return NDStructure.contentEquals(this, other)
     }
 
-- 
2.34.1


From d5ba816b7daa64a089c3b07e4aa28ab1e10b74f8 Mon Sep 17 00:00:00 2001
From: darksnake <altavir@gmail.com>
Date: Sat, 13 Mar 2021 18:00:47 +0300
Subject: [PATCH 23/37] WIP Matrix refactor

---
 .../kscience/kmath/linear/LinearSpace.kt      |  2 +-
 .../kscience/kmath/linear/LupDecomposition.kt |  4 +-
 .../space/kscience/kmath/linear/MatrixTest.kt |  3 +-
 .../kscience/kmath/dimensions/Wrappers.kt     | 31 +++++++------
 .../kscience/kmath/ejml/EjmlLinearSpace.kt    | 39 ++++++----------
 .../space/kscience/kmath/real/RealMatrix.kt   | 29 ++++++------
 .../kotlin/space/kscience/kmath/real/dot.kt   | 46 +++++++++----------
 7 files changed, 74 insertions(+), 80 deletions(-)

diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpace.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpace.kt
index 5800bdd0d..4a9d2c9b3 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpace.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpace.kt
@@ -22,7 +22,7 @@ public typealias Vector<T> = Point<T>
  * @param T the type of items in the matrices.
  * @param M the type of operated matrices.
  */
-public interface LinearSpace<T : Any, A : Ring<T>> {
+public interface LinearSpace<T : Any, out A : Ring<T>> {
     public val elementAlgebra: A
 
     /**
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LupDecomposition.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LupDecomposition.kt
index 5d68534bc..0937f1e19 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LupDecomposition.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LupDecomposition.kt
@@ -228,7 +228,7 @@ public inline fun <reified T : Comparable<T>> LinearSpace<T, Field<T>>.inverseWi
 
 
 @OptIn(UnstableKMathAPI::class)
-public fun RealLinearSpace.solveWithLup(a: Matrix<Double>, b: Matrix<Double>): Matrix<Double> {
+public fun LinearSpace<Double, RealField>.solveWithLup(a: Matrix<Double>, b: Matrix<Double>): Matrix<Double> {
     // Use existing decomposition if it is provided by matrix
     val bufferFactory: MutableBufferFactory<Double> = MutableBuffer.Companion::real
     val decomposition: LupDecomposition<Double> = a.getFeature() ?: lup(bufferFactory, a) { it < 1e-11 }
@@ -238,5 +238,5 @@ public fun RealLinearSpace.solveWithLup(a: Matrix<Double>, b: Matrix<Double>): M
 /**
  * Inverses a square matrix using LUP decomposition. Non square matrix will throw a error.
  */
-public fun RealLinearSpace.inverseWithLup(matrix: Matrix<Double>): Matrix<Double> =
+public fun LinearSpace<Double, RealField>.inverseWithLup(matrix: Matrix<Double>): Matrix<Double> =
     solveWithLup(matrix, one(matrix.rowNum, matrix.colNum))
\ No newline at end of file
diff --git a/kmath-core/src/commonTest/kotlin/space/kscience/kmath/linear/MatrixTest.kt b/kmath-core/src/commonTest/kotlin/space/kscience/kmath/linear/MatrixTest.kt
index 5cf83889a..27374e93f 100644
--- a/kmath-core/src/commonTest/kotlin/space/kscience/kmath/linear/MatrixTest.kt
+++ b/kmath-core/src/commonTest/kotlin/space/kscience/kmath/linear/MatrixTest.kt
@@ -2,7 +2,6 @@ package space.kscience.kmath.linear
 
 import space.kscience.kmath.nd.NDStructure
 import space.kscience.kmath.nd.as2D
-import space.kscience.kmath.operations.invoke
 import kotlin.test.Test
 import kotlin.test.assertEquals
 
@@ -17,7 +16,7 @@ class MatrixTest {
 
     @Test
     fun testBuilder() {
-        val matrix = Matrix.build(2, 3)(
+        val matrix = LinearSpace.real.matrix(2, 3)(
             1.0, 0.0, 0.0,
             0.0, 1.0, 2.0
         )
diff --git a/kmath-dimensions/src/commonMain/kotlin/space/kscience/kmath/dimensions/Wrappers.kt b/kmath-dimensions/src/commonMain/kotlin/space/kscience/kmath/dimensions/Wrappers.kt
index 89ff97f14..f7e14b29f 100644
--- a/kmath-dimensions/src/commonMain/kotlin/space/kscience/kmath/dimensions/Wrappers.kt
+++ b/kmath-dimensions/src/commonMain/kotlin/space/kscience/kmath/dimensions/Wrappers.kt
@@ -2,7 +2,8 @@ package space.kscience.kmath.dimensions
 
 import space.kscience.kmath.linear.*
 import space.kscience.kmath.nd.Structure2D
-import space.kscience.kmath.operations.invoke
+import space.kscience.kmath.operations.RealField
+import space.kscience.kmath.operations.Ring
 
 /**
  * A matrix with compile-time controlled dimension
@@ -77,7 +78,7 @@ public inline class DPointWrapper<T, D : Dimension>(public val point: Point<T>)
 /**
  * Basic operations on dimension-safe matrices. Operates on [Matrix]
  */
-public inline class DMatrixContext<T : Any>(public val context: LinearSpace<T, Matrix<T>>) {
+public inline class DMatrixContext<T : Any, out A : Ring<T>>(public val context: LinearSpace<T, A>) {
     public inline fun <reified R : Dimension, reified C : Dimension> Matrix<T>.coerce(): DMatrix<T, R, C> {
         require(rowNum == Dimension.dim<R>().toInt()) {
             "Row number mismatch: expected ${Dimension.dim<R>()} but found $rowNum"
@@ -93,13 +94,15 @@ public inline class DMatrixContext<T : Any>(public val context: LinearSpace<T, M
     /**
      * Produce a matrix with this context and given dimensions
      */
-    public inline fun <reified R : Dimension, reified C : Dimension> produce(noinline initializer: (i: Int, j: Int) -> T): DMatrix<T, R, C> {
+    public inline fun <reified R : Dimension, reified C : Dimension> produce(
+        noinline initializer: A.(i: Int, j: Int) -> T
+    ): DMatrix<T, R, C> {
         val rows = Dimension.dim<R>()
         val cols = Dimension.dim<C>()
         return context.buildMatrix(rows.toInt(), cols.toInt(), initializer).coerce<R, C>()
     }
 
-    public inline fun <reified D : Dimension> point(noinline initializer: (Int) -> T): DPoint<T, D> {
+    public inline fun <reified D : Dimension> point(noinline initializer: A.(Int) -> T): DPoint<T, D> {
         val size = Dimension.dim<D>()
 
         return DPoint.coerceUnsafe(
@@ -112,31 +115,31 @@ public inline class DMatrixContext<T : Any>(public val context: LinearSpace<T, M
 
     public inline infix fun <reified R1 : Dimension, reified C1 : Dimension, reified C2 : Dimension> DMatrix<T, R1, C1>.dot(
         other: DMatrix<T, C1, C2>,
-    ): DMatrix<T, R1, C2> = context { this@dot dot other }.coerce()
+    ): DMatrix<T, R1, C2> = context.run { this@dot dot other }.coerce()
 
     public inline infix fun <reified R : Dimension, reified C : Dimension> DMatrix<T, R, C>.dot(vector: DPoint<T, C>): DPoint<T, R> =
-        DPoint.coerceUnsafe(context { this@dot dot vector })
+        DPoint.coerceUnsafe(context.run { this@dot dot vector })
 
     public inline operator fun <reified R : Dimension, reified C : Dimension> DMatrix<T, R, C>.times(value: T): DMatrix<T, R, C> =
-        context { this@times.times(value) }.coerce()
+        context.run { this@times.times(value) }.coerce()
 
     public inline operator fun <reified R : Dimension, reified C : Dimension> T.times(m: DMatrix<T, R, C>): DMatrix<T, R, C> =
         m * this
 
     public inline operator fun <reified R : Dimension, reified C : Dimension> DMatrix<T, C, R>.plus(other: DMatrix<T, C, R>): DMatrix<T, C, R> =
-        context { this@plus + other }.coerce()
+        context.run { this@plus + other }.coerce()
 
     public inline operator fun <reified R : Dimension, reified C : Dimension> DMatrix<T, C, R>.minus(other: DMatrix<T, C, R>): DMatrix<T, C, R> =
-        context { this@minus + other }.coerce()
+        context.run { this@minus + other }.coerce()
 
     public inline operator fun <reified R : Dimension, reified C : Dimension> DMatrix<T, C, R>.unaryMinus(): DMatrix<T, C, R> =
-        context { this@unaryMinus.unaryMinus() }.coerce()
+        context.run { this@unaryMinus.unaryMinus() }.coerce()
 
     public inline fun <reified R : Dimension, reified C : Dimension> DMatrix<T, C, R>.transpose(): DMatrix<T, R, C> =
-        context { (this@transpose as Matrix<T>).transpose() }.coerce()
+        context.run { (this@transpose as Matrix<T>).transpose() }.coerce()
 
     public companion object {
-        public val real: DMatrixContext<Double> = DMatrixContext(LinearSpace.real)
+        public val real: DMatrixContext<Double, RealField> = DMatrixContext(LinearSpace.real)
     }
 }
 
@@ -144,11 +147,11 @@ public inline class DMatrixContext<T : Any>(public val context: LinearSpace<T, M
 /**
  * A square unit matrix
  */
-public inline fun <reified D : Dimension> DMatrixContext<Double>.one(): DMatrix<Double, D, D> = produce { i, j ->
+public inline fun <reified D : Dimension> DMatrixContext<Double, RealField>.one(): DMatrix<Double, D, D> = produce { i, j ->
     if (i == j) 1.0 else 0.0
 }
 
-public inline fun <reified R : Dimension, reified C : Dimension> DMatrixContext<Double>.zero(): DMatrix<Double, R, C> =
+public inline fun <reified R : Dimension, reified C : Dimension> DMatrixContext<Double, RealField>.zero(): DMatrix<Double, R, C> =
     produce { _, _ ->
         0.0
     }
\ No newline at end of file
diff --git a/kmath-ejml/src/main/kotlin/space/kscience/kmath/ejml/EjmlLinearSpace.kt b/kmath-ejml/src/main/kotlin/space/kscience/kmath/ejml/EjmlLinearSpace.kt
index 339e06459..57ce977fd 100644
--- a/kmath-ejml/src/main/kotlin/space/kscience/kmath/ejml/EjmlLinearSpace.kt
+++ b/kmath-ejml/src/main/kotlin/space/kscience/kmath/ejml/EjmlLinearSpace.kt
@@ -44,7 +44,7 @@ public object EjmlLinearSpace : LinearSpace<Double, RealField>, ScaleOperations<
 
     override fun buildVector(size: Int, initializer: RealField.(Int) -> Double): Vector<Double> =
         EjmlVector(SimpleMatrix(size, 1).also {
-            (0 until it.numRows()).forEach { row -> it[row, 0] = initializer(row) }
+            (0 until it.numRows()).forEach { row -> it[row, 0] = RealField.initializer(row) }
         })
 
     private fun SimpleMatrix.wrapMatrix() = EjmlMatrix(this)
@@ -59,43 +59,34 @@ public object EjmlLinearSpace : LinearSpace<Double, RealField>, ScaleOperations<
         EjmlVector(toEjml().origin.mult(vector.toEjml().origin))
 
     public override operator fun Matrix<Double>.minus(other: Matrix<Double>): EjmlMatrix =
-        EjmlMatrix(toEjml().origin - other.toEjml().origin)
+        (toEjml().origin - other.toEjml().origin).wrapMatrix()
 
     public override fun scale(a: Matrix<Double>, value: Double): EjmlMatrix =
         a.toEjml().origin.scale(value).wrapMatrix()
 
     public override operator fun Matrix<Double>.times(value: Double): EjmlMatrix =
-        EjmlMatrix(toEjml().origin.scale(value))
+        toEjml().origin.scale(value).wrapMatrix()
 
     override fun Vector<Double>.unaryMinus(): EjmlVector =
         toEjml().origin.negative().wrapVector()
 
-    override fun Matrix<Double>.plus(other: Matrix<Double>): Matrix<Double> {
-        TODO("Not yet implemented")
-    }
+    override fun Matrix<Double>.plus(other: Matrix<Double>): EjmlMatrix =
+        (toEjml().origin + other.toEjml().origin).wrapMatrix()
 
-    override fun Vector<Double>.plus(other: Vector<Double>): Vector<Double> {
-        TODO("Not yet implemented")
-    }
+    override fun Vector<Double>.plus(other: Vector<Double>): EjmlVector =
+        (toEjml().origin + other.toEjml().origin).wrapVector()
 
-    override fun Vector<Double>.minus(other: Vector<Double>): Vector<Double> {
-        TODO("Not yet implemented")
-    }
+    override fun Vector<Double>.minus(other: Vector<Double>): EjmlVector =
+        (toEjml().origin - other.toEjml().origin).wrapVector()
 
-    override fun Double.times(m: Matrix<Double>): Matrix<Double> {
-        TODO("Not yet implemented")
-    }
+    override fun Double.times(m: Matrix<Double>): EjmlMatrix =
+        m.toEjml().origin.scale(this).wrapMatrix()
 
-    override fun Vector<Double>.times(value: Double): Vector<Double> {
-        TODO("Not yet implemented")
-    }
+    override fun Vector<Double>.times(value: Double): EjmlVector =
+        toEjml().origin.scale(value).wrapVector()
 
-    override fun Double.times(v: Vector<Double>): Vector<Double> {
-        TODO("Not yet implemented")
-    }
-
-    public override fun add(a: Matrix<Double>, b: Matrix<Double>): EjmlMatrix =
-        EjmlMatrix(a.toEjml().origin + b.toEjml().origin)
+    override fun Double.times(v: Vector<Double>): EjmlVector =
+        v.toEjml().origin.scale(this).wrapVector()
 }
 
 /**
diff --git a/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/RealMatrix.kt b/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/RealMatrix.kt
index b93c430f9..640615cc9 100644
--- a/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/RealMatrix.kt
+++ b/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/RealMatrix.kt
@@ -2,6 +2,7 @@ package space.kscience.kmath.real
 
 import space.kscience.kmath.linear.*
 import space.kscience.kmath.misc.UnstableKMathAPI
+import space.kscience.kmath.operations.RealField
 import space.kscience.kmath.structures.Buffer
 import space.kscience.kmath.structures.RealBuffer
 import space.kscience.kmath.structures.asIterable
@@ -21,11 +22,11 @@ import kotlin.math.pow
 
 public typealias RealMatrix = Matrix<Double>
 
-public fun realMatrix(rowNum: Int, colNum: Int, initializer: (i: Int, j: Int) -> Double): RealMatrix =
+public fun realMatrix(rowNum: Int, colNum: Int, initializer: RealField.(i: Int, j: Int) -> Double): RealMatrix =
     LinearSpace.real.buildMatrix(rowNum, colNum, initializer)
 
 public fun Array<DoubleArray>.toMatrix(): RealMatrix {
-    return LinearSpace.real.buildMatrix(size, this[0].size) { row, col -> this[row][col] }
+    return LinearSpace.real.buildMatrix(size, this[0].size) { row, col -> this@toMatrix[row][col] }
 }
 
 public fun Sequence<DoubleArray>.toMatrix(): RealMatrix = toList().let {
@@ -43,37 +44,37 @@ public fun RealMatrix.repeatStackVertical(n: Int): RealMatrix =
 
 public operator fun RealMatrix.times(double: Double): RealMatrix =
     LinearSpace.real.buildMatrix(rowNum, colNum) { row, col ->
-        this[row, col] * double
+        get(row, col) * double
     }
 
 public operator fun RealMatrix.plus(double: Double): RealMatrix =
     LinearSpace.real.buildMatrix(rowNum, colNum) { row, col ->
-        this[row, col] + double
+        get(row, col) + double
     }
 
 public operator fun RealMatrix.minus(double: Double): RealMatrix =
     LinearSpace.real.buildMatrix(rowNum, colNum) { row, col ->
-        this[row, col] - double
+        get(row, col) - double
     }
 
 public operator fun RealMatrix.div(double: Double): RealMatrix =
     LinearSpace.real.buildMatrix(rowNum, colNum) { row, col ->
-        this[row, col] / double
+        get(row, col) / double
     }
 
 public operator fun Double.times(matrix: RealMatrix): RealMatrix =
     LinearSpace.real.buildMatrix(matrix.rowNum, matrix.colNum) { row, col ->
-        this * matrix[row, col]
+        this@times * matrix[row, col]
     }
 
 public operator fun Double.plus(matrix: RealMatrix): RealMatrix =
     LinearSpace.real.buildMatrix(matrix.rowNum, matrix.colNum) { row, col ->
-        this + matrix[row, col]
+        this@plus + matrix[row, col]
     }
 
 public operator fun Double.minus(matrix: RealMatrix): RealMatrix =
     LinearSpace.real.buildMatrix(matrix.rowNum, matrix.colNum) { row, col ->
-        this - matrix[row, col]
+        this@minus - matrix[row, col]
     }
 
 // TODO: does this operation make sense? Should it be 'this/matrix[row, col]'?
@@ -87,13 +88,13 @@ public operator fun Double.minus(matrix: RealMatrix): RealMatrix =
 
 @UnstableKMathAPI
 public operator fun RealMatrix.times(other: RealMatrix): RealMatrix =
-    LinearSpace.real.buildMatrix(rowNum, colNum) { row, col -> this[row, col] * other[row, col] }
+    LinearSpace.real.buildMatrix(rowNum, colNum) { row, col -> this@times[row, col] * other[row, col] }
 
 public operator fun RealMatrix.plus(other: RealMatrix): RealMatrix =
-    LinearSpace.real.add(this, other)
+    LinearSpace.real.run { this@plus + other }
 
 public operator fun RealMatrix.minus(other: RealMatrix): RealMatrix =
-    LinearSpace.real.buildMatrix(rowNum, colNum) { row, col -> this[row, col] - other[row, col] }
+    LinearSpace.real.buildMatrix(rowNum, colNum) { row, col -> this@minus[row, col] - other[row, col] }
 
 /*
  *  Operations on columns
@@ -102,14 +103,14 @@ public operator fun RealMatrix.minus(other: RealMatrix): RealMatrix =
 public inline fun RealMatrix.appendColumn(crossinline mapper: (Buffer<Double>) -> Double): RealMatrix =
     LinearSpace.real.buildMatrix(rowNum, colNum + 1) { row, col ->
         if (col < colNum)
-            this[row, col]
+            get(row, col)
         else
             mapper(rows[row])
     }
 
 public fun RealMatrix.extractColumns(columnRange: IntRange): RealMatrix =
     LinearSpace.real.buildMatrix(rowNum, columnRange.count()) { row, col ->
-        this[row, columnRange.first + col]
+        this@extractColumns[row, columnRange.first + col]
     }
 
 public fun RealMatrix.extractColumn(columnIndex: Int): RealMatrix =
diff --git a/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/dot.kt b/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/dot.kt
index cbfb364c1..5a66b55bd 100644
--- a/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/dot.kt
+++ b/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/dot.kt
@@ -1,31 +1,31 @@
 package space.kscience.kmath.real
 
-import space.kscience.kmath.linear.BufferMatrix
-import space.kscience.kmath.structures.Buffer
-import space.kscience.kmath.structures.RealBuffer
+import space.kscience.kmath.linear.LinearSpace
+import space.kscience.kmath.nd.Matrix
 
 
 /**
  * Optimized dot product for real matrices
  */
-public infix fun BufferMatrix<Double>.dot(other: BufferMatrix<Double>): BufferMatrix<Double> {
-    require(colNum == other.rowNum) { "Matrix dot operation dimension mismatch: ($rowNum, $colNum) x (${other.rowNum}, ${other.colNum})" }
-    val resultArray = DoubleArray(this.rowNum * other.colNum)
-
-    //convert to array to insure there is no memory indirection
-    fun Buffer<Double>.unsafeArray() = if (this is RealBuffer)
-        this.array
-    else
-        DoubleArray(size) { get(it) }
-
-    val a = this.buffer.unsafeArray()
-    val b = other.buffer.unsafeArray()
-
-    for (i in (0 until rowNum))
-        for (j in (0 until other.colNum))
-            for (k in (0 until colNum))
-                resultArray[i * other.colNum + j] += a[i * colNum + k] * b[k * other.colNum + j]
-
-    val buffer = RealBuffer(resultArray)
-    return BufferMatrix(rowNum, other.colNum, buffer)
+public infix fun Matrix<Double>.dot(other: Matrix<Double>): Matrix<Double> = LinearSpace.real.run{
+    this@dot dot other
+//    require(colNum == other.rowNum) { "Matrix dot operation dimension mismatch: ($rowNum, $colNum) x (${other.rowNum}, ${other.colNum})" }
+//    val resultArray = DoubleArray(this.rowNum * other.colNum)
+//
+//    //convert to array to insure there is no memory indirection
+//    fun Buffer<Double>.unsafeArray() = if (this is RealBuffer)
+//        this.array
+//    else
+//        DoubleArray(size) { get(it) }
+//
+//    val a = this.buffer.unsafeArray()
+//    val b = other.buffer.unsafeArray()
+//
+//    for (i in (0 until rowNum))
+//        for (j in (0 until other.colNum))
+//            for (k in (0 until colNum))
+//                resultArray[i * other.colNum + j] += a[i * colNum + k] * b[k * other.colNum + j]
+//
+//    val buffer = RealBuffer(resultArray)
+//    return BufferMatrix(rowNum, other.colNum, buffer)
 }
\ No newline at end of file
-- 
2.34.1


From 5e6f65a181c1a04cf5b992ab350972cb41d6ac93 Mon Sep 17 00:00:00 2001
From: darksnake <altavir@gmail.com>
Date: Sat, 13 Mar 2021 18:19:10 +0300
Subject: [PATCH 24/37] WIP Matrix refactor

---
 .../kmath/structures/typeSafeDimensions.kt    |  4 +-
 .../kscience/kmath/commons/linear/CMMatrix.kt |  4 +-
 .../kscience/kmath/commons/linear/CMSolver.kt |  4 +-
 .../kscience/kmath/linear/MatrixBuilder.kt    | 25 ++++++++++--
 .../space/kscience/kmath/linear/MatrixTest.kt |  2 +-
 .../kscience/kmath/linear/RealLUSolverTest.kt | 14 +++----
 .../kmath/structures/NumberNDFieldTest.kt     |  5 ++-
 .../kotlin/space/kscience/kmath/real/dot.kt   | 19 ----------
 .../kaceince/kmath/real/RealMatrixTest.kt     | 38 +++++++++----------
 .../kaceince/kmath/real/RealVectorTest.kt     |  4 +-
 10 files changed, 60 insertions(+), 59 deletions(-)

diff --git a/examples/src/main/kotlin/space/kscience/kmath/structures/typeSafeDimensions.kt b/examples/src/main/kotlin/space/kscience/kmath/structures/typeSafeDimensions.kt
index fdd631238..d2d130ab4 100644
--- a/examples/src/main/kotlin/space/kscience/kmath/structures/typeSafeDimensions.kt
+++ b/examples/src/main/kotlin/space/kscience/kmath/structures/typeSafeDimensions.kt
@@ -5,7 +5,7 @@ import space.kscience.kmath.dimensions.D3
 import space.kscience.kmath.dimensions.DMatrixContext
 import space.kscience.kmath.dimensions.Dimension
 
-private fun DMatrixContext<Double>.simple() {
+private fun DMatrixContext<Double, *>.simple() {
     val m1 = produce<D2, D3> { i, j -> (i + j).toDouble() }
     val m2 = produce<D3, D2> { i, j -> (i + j).toDouble() }
 
@@ -17,7 +17,7 @@ private object D5 : Dimension {
     override val dim: UInt = 5u
 }
 
-private fun DMatrixContext<Double>.custom() {
+private fun DMatrixContext<Double, *>.custom() {
     val m1 = produce<D2, D5> { i, j -> (i + j).toDouble() }
     val m2 = produce<D5, D2> { i, j -> (i - j).toDouble() }
     val m3 = produce<D2, D2> { i, j -> (i - j).toDouble() }
diff --git 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
index c1c3d716a..b462a1a36 100644
--- 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
@@ -99,8 +99,8 @@ public object CMLinearSpace : LinearSpace<Double, RealField> {
         ArrayRealVector(array).wrap()
     }
 
-    private fun RealMatrix.wrap(): CMMatrix = CMMatrix(this)
-    private fun RealVector.wrap(): CMVector = CMVector(this)
+    internal fun RealMatrix.wrap(): CMMatrix = CMMatrix(this)
+    internal fun RealVector.wrap(): CMVector = CMVector(this)
 
     override fun buildVector(size: Int, initializer: RealField.(Int) -> Double): Vector<Double> =
         ArrayRealVector(DoubleArray(size) { RealField.initializer(it) }).wrap()
diff --git a/kmath-commons/src/main/kotlin/space/kscience/kmath/commons/linear/CMSolver.kt b/kmath-commons/src/main/kotlin/space/kscience/kmath/commons/linear/CMSolver.kt
index ff4727aa2..b5fd0154e 100644
--- a/kmath-commons/src/main/kotlin/space/kscience/kmath/commons/linear/CMSolver.kt
+++ b/kmath-commons/src/main/kotlin/space/kscience/kmath/commons/linear/CMSolver.kt
@@ -27,7 +27,7 @@ public fun CMLinearSpace.solve(
     a: Matrix<Double>,
     b: Matrix<Double>,
     decomposition: CMDecomposition = CMDecomposition.LUP
-): CMMatrix = solver(a, decomposition).solve(b.toCM().origin).asMatrix()
+): CMMatrix = solver(a, decomposition).solve(b.toCM().origin).wrap()
 
 public fun CMLinearSpace.solve(
     a: Matrix<Double>,
@@ -38,4 +38,4 @@ public fun CMLinearSpace.solve(
 public fun CMLinearSpace.inverse(
     a: Matrix<Double>,
     decomposition: CMDecomposition = CMDecomposition.LUP
-): CMMatrix = solver(a, decomposition).inverse.asMatrix()
+): CMMatrix = solver(a, decomposition).inverse.wrap()
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixBuilder.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixBuilder.kt
index 28df78dad..6814cb561 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixBuilder.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixBuilder.kt
@@ -3,11 +3,30 @@ package space.kscience.kmath.linear
 import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.operations.Ring
 
+public class MatrixBuilder<T : Any, A : Ring<T>>(
+    public val linearSpace: LinearSpace<T, A>,
+    public val rows: Int,
+    public val columns: Int,
+) {
+    public operator fun invoke(vararg elements: T): Matrix<T> {
+        require(rows * columns == elements.size) { "The number of elements ${elements.size} is not equal $rows * $columns" }
+        return linearSpace.buildMatrix(rows, columns) { i, j -> elements[i * columns + j] }
+    }
+
+    //TODO add specific matrix builder functions like diagonal, etc
+}
 
 @UnstableKMathAPI
-public fun <T : Any> LinearSpace<T, Ring<T>>.matrix(rows: Int, columns: Int, vararg elements: T): Matrix<T> {
-    require(rows * columns == elements.size) { "The number of elements ${elements.size} is not equal $rows * $columns" }
-    return buildMatrix(rows, columns) { i, j -> elements[i * columns + j] }
+public fun <T : Any, A : Ring<T>> LinearSpace<T, A>.matrix(rows: Int, columns: Int): MatrixBuilder<T, A> =
+    MatrixBuilder(this, rows, columns)
+
+/**
+ * Build a square matrix from given elements.
+ */
+@UnstableKMathAPI
+public fun <T : Any> LinearSpace<T, Ring<T>>.square(vararg elements: T): Matrix<T> {
+    val size: Int = kotlin.math.sqrt(elements.size.toDouble()).toInt()
+    return matrix(size,size)(*elements)
 }
 
 @UnstableKMathAPI
diff --git a/kmath-core/src/commonTest/kotlin/space/kscience/kmath/linear/MatrixTest.kt b/kmath-core/src/commonTest/kotlin/space/kscience/kmath/linear/MatrixTest.kt
index 27374e93f..53cdd4522 100644
--- a/kmath-core/src/commonTest/kotlin/space/kscience/kmath/linear/MatrixTest.kt
+++ b/kmath-core/src/commonTest/kotlin/space/kscience/kmath/linear/MatrixTest.kt
@@ -38,7 +38,7 @@ class MatrixTest {
         infix fun Matrix<Double>.pow(power: Int): Matrix<Double> {
             var res = this
             repeat(power - 1) {
-                res = RealLinearSpace.invoke { res dot this@pow }
+                res = LinearSpace.real.run { res dot this@pow }
             }
             return res
         }
diff --git a/kmath-core/src/commonTest/kotlin/space/kscience/kmath/linear/RealLUSolverTest.kt b/kmath-core/src/commonTest/kotlin/space/kscience/kmath/linear/RealLUSolverTest.kt
index 4d6b8f5be..802849a1e 100644
--- a/kmath-core/src/commonTest/kotlin/space/kscience/kmath/linear/RealLUSolverTest.kt
+++ b/kmath-core/src/commonTest/kotlin/space/kscience/kmath/linear/RealLUSolverTest.kt
@@ -14,12 +14,12 @@ class RealLUSolverTest {
 
     @Test
     fun testDecomposition() {
-        val matrix = Matrix.square(
-            3.0, 1.0,
-            1.0, 3.0
-        )
-
         LinearSpace.real.run {
+            val matrix = square(
+                3.0, 1.0,
+                1.0, 3.0
+            )
+
             val lup = lup(matrix)
 
             //Check determinant
@@ -31,14 +31,14 @@ class RealLUSolverTest {
 
     @Test
     fun testInvert() {
-        val matrix = Matrix.square(
+        val matrix = LinearSpace.real.square(
             3.0, 1.0,
             1.0, 3.0
         )
 
         val inverted = LinearSpace.real.inverseWithLup(matrix)
 
-        val expected = Matrix.square(
+        val expected = LinearSpace.real.square(
             0.375, -0.125,
             -0.125, 0.375
         )
diff --git a/kmath-core/src/commonTest/kotlin/space/kscience/kmath/structures/NumberNDFieldTest.kt b/kmath-core/src/commonTest/kotlin/space/kscience/kmath/structures/NumberNDFieldTest.kt
index 23b0e7348..dd7871f9a 100644
--- a/kmath-core/src/commonTest/kotlin/space/kscience/kmath/structures/NumberNDFieldTest.kt
+++ b/kmath-core/src/commonTest/kotlin/space/kscience/kmath/structures/NumberNDFieldTest.kt
@@ -1,5 +1,6 @@
 package space.kscience.kmath.structures
 
+import space.kscience.kmath.linear.LinearSpace
 import space.kscience.kmath.nd.*
 import space.kscience.kmath.operations.Norm
 import space.kscience.kmath.operations.invoke
@@ -33,7 +34,9 @@ class NumberNDFieldTest {
     @Test
     fun testGeneration() {
 
-        val array = Structure2D.real(3, 3) { i, j -> (i * 10 + j).toDouble() }
+        val array = LinearSpace.real.buildMatrix(3, 3) { i, j ->
+            (i * 10 + j).toDouble()
+        }
 
         for (i in 0..2) {
             for (j in 0..2) {
diff --git a/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/dot.kt b/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/dot.kt
index 5a66b55bd..1a7c1213c 100644
--- a/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/dot.kt
+++ b/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/dot.kt
@@ -9,23 +9,4 @@ import space.kscience.kmath.nd.Matrix
  */
 public infix fun Matrix<Double>.dot(other: Matrix<Double>): Matrix<Double> = LinearSpace.real.run{
     this@dot dot other
-//    require(colNum == other.rowNum) { "Matrix dot operation dimension mismatch: ($rowNum, $colNum) x (${other.rowNum}, ${other.colNum})" }
-//    val resultArray = DoubleArray(this.rowNum * other.colNum)
-//
-//    //convert to array to insure there is no memory indirection
-//    fun Buffer<Double>.unsafeArray() = if (this is RealBuffer)
-//        this.array
-//    else
-//        DoubleArray(size) { get(it) }
-//
-//    val a = this.buffer.unsafeArray()
-//    val b = other.buffer.unsafeArray()
-//
-//    for (i in (0 until rowNum))
-//        for (j in (0 until other.colNum))
-//            for (k in (0 until colNum))
-//                resultArray[i * other.colNum + j] += a[i * colNum + k] * b[k * other.colNum + j]
-//
-//    val buffer = RealBuffer(resultArray)
-//    return BufferMatrix(rowNum, other.colNum, buffer)
 }
\ No newline at end of file
diff --git a/kmath-for-real/src/commonTest/kotlin/kaceince/kmath/real/RealMatrixTest.kt b/kmath-for-real/src/commonTest/kotlin/kaceince/kmath/real/RealMatrixTest.kt
index 9e2778be9..6ab11b03b 100644
--- a/kmath-for-real/src/commonTest/kotlin/kaceince/kmath/real/RealMatrixTest.kt
+++ b/kmath-for-real/src/commonTest/kotlin/kaceince/kmath/real/RealMatrixTest.kt
@@ -1,7 +1,7 @@
 package kaceince.kmath.real
 
-import space.kscience.kmath.linear.Matrix
-import space.kscience.kmath.linear.build
+import space.kscience.kmath.linear.LinearSpace
+import space.kscience.kmath.linear.matrix
 import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.real.*
 import space.kscience.kmath.structures.contentEquals
@@ -30,11 +30,11 @@ internal class RealMatrixTest {
 
     @Test
     fun testRepeatStackVertical() {
-        val matrix1 = Matrix.build(2, 3)(
+        val matrix1 = LinearSpace.real.matrix(2, 3)(
             1.0, 0.0, 0.0,
             0.0, 1.0, 2.0
         )
-        val matrix2 = Matrix.build(6, 3)(
+        val matrix2 = LinearSpace.real.matrix(6, 3)(
             1.0, 0.0, 0.0,
             0.0, 1.0, 2.0,
             1.0, 0.0, 0.0,
@@ -47,12 +47,12 @@ internal class RealMatrixTest {
 
     @Test
     fun testMatrixAndDouble() {
-        val matrix1 = Matrix.build(2, 3)(
+        val matrix1 = LinearSpace.real.matrix(2, 3)(
             1.0, 0.0, 3.0,
             4.0, 6.0, 2.0
         )
         val matrix2 = (matrix1 * 2.5 + 1.0 - 2.0) / 2.0
-        val expectedResult = Matrix.build(2, 3)(
+        val expectedResult = LinearSpace.real.matrix(2, 3)(
             0.75, -0.5, 3.25,
             4.5, 7.0, 2.0
         )
@@ -61,13 +61,13 @@ internal class RealMatrixTest {
 
     @Test
     fun testDoubleAndMatrix() {
-        val matrix1 = Matrix.build(2, 3)(
+        val matrix1 = LinearSpace.real.matrix(2, 3)(
             1.0, 0.0, 3.0,
             4.0, 6.0, 2.0
         )
         val matrix2 = 20.0 - (10.0 + (5.0 * matrix1))
         //val matrix2 = 10.0 + (5.0 * matrix1)
-        val expectedResult = Matrix.build(2, 3)(
+        val expectedResult = LinearSpace.real.matrix(2, 3)(
             5.0, 10.0, -5.0,
             -10.0, -20.0, 0.0
         )
@@ -76,15 +76,15 @@ internal class RealMatrixTest {
 
     @Test
     fun testSquareAndPower() {
-        val matrix1 = Matrix.build(2, 3)(
+        val matrix1 = LinearSpace.real.matrix(2, 3)(
             -1.0, 0.0, 3.0,
             4.0, -6.0, -2.0
         )
-        val matrix2 = Matrix.build(2, 3)(
+        val matrix2 = LinearSpace.real.matrix(2, 3)(
             1.0, 0.0, 9.0,
             16.0, 36.0, 4.0
         )
-        val matrix3 = Matrix.build(2, 3)(
+        val matrix3 = LinearSpace.real.matrix(2, 3)(
             -1.0, 0.0, 27.0,
             64.0, -216.0, -8.0
         )
@@ -95,16 +95,16 @@ internal class RealMatrixTest {
     @OptIn(UnstableKMathAPI::class)
     @Test
     fun testTwoMatrixOperations() {
-        val matrix1 = Matrix.build(2, 3)(
+        val matrix1 = LinearSpace.real.matrix(2, 3)(
             -1.0, 0.0, 3.0,
             4.0, -6.0, 7.0
         )
-        val matrix2 = Matrix.build(2, 3)(
+        val matrix2 = LinearSpace.real.matrix(2, 3)(
             1.0, 0.0, 3.0,
             4.0, 6.0, -2.0
         )
         val result = matrix1 * matrix2 + matrix1 - matrix2
-        val expectedResult = Matrix.build(2, 3)(
+        val expectedResult = LinearSpace.real.matrix(2, 3)(
             -3.0, 0.0, 9.0,
             16.0, -48.0, -5.0
         )
@@ -113,16 +113,16 @@ internal class RealMatrixTest {
 
     @Test
     fun testColumnOperations() {
-        val matrix1 = Matrix.build(2, 4)(
+        val matrix1 = LinearSpace.real.matrix(2, 4)(
             -1.0, 0.0, 3.0, 15.0,
             4.0, -6.0, 7.0, -11.0
         )
-        val matrix2 = Matrix.build(2, 5)(
+        val matrix2 = LinearSpace.real.matrix(2, 5)(
             -1.0, 0.0, 3.0, 15.0, -1.0,
             4.0, -6.0, 7.0, -11.0, 4.0
         )
-        val col1 = Matrix.build(2, 1)(0.0, -6.0)
-        val cols1to2 = Matrix.build(2, 2)(
+        val col1 = LinearSpace.real.matrix(2, 1)(0.0, -6.0)
+        val cols1to2 = LinearSpace.real.matrix(2, 2)(
             0.0, 3.0,
             -6.0, 7.0
         )
@@ -147,7 +147,7 @@ internal class RealMatrixTest {
 
     @Test
     fun testAllElementOperations() {
-        val matrix1 = Matrix.build(2, 4)(
+        val matrix1 = LinearSpace.real.matrix(2, 4)(
             -1.0, 0.0, 3.0, 15.0,
             4.0, -6.0, 7.0, -11.0
         )
diff --git a/kmath-for-real/src/commonTest/kotlin/kaceince/kmath/real/RealVectorTest.kt b/kmath-for-real/src/commonTest/kotlin/kaceince/kmath/real/RealVectorTest.kt
index 5d032de67..59d55110f 100644
--- a/kmath-for-real/src/commonTest/kotlin/kaceince/kmath/real/RealVectorTest.kt
+++ b/kmath-for-real/src/commonTest/kotlin/kaceince/kmath/real/RealVectorTest.kt
@@ -2,9 +2,7 @@ package kaceince.kmath.real
 
 import space.kscience.kmath.linear.LinearSpace
 import space.kscience.kmath.linear.asMatrix
-import space.kscience.kmath.linear.real
 import space.kscience.kmath.linear.transpose
-import space.kscience.kmath.operations.invoke
 import space.kscience.kmath.real.plus
 import space.kscience.kmath.structures.Buffer
 import kotlin.test.Test
@@ -32,7 +30,7 @@ internal class RealVectorTest {
         val vector2 =  Buffer.real(5) { 5 - it.toDouble() }
         val matrix1 = vector1.asMatrix()
         val matrix2 = vector2.asMatrix().transpose()
-        val product = LinearSpace.real { matrix1 dot matrix2 }
+        val product = LinearSpace.real.run { matrix1 dot matrix2 }
         assertEquals(5.0, product[1, 0])
         assertEquals(6.0, product[2, 2])
     }
-- 
2.34.1


From be9398b3226bebf2a5afbd561c6b5fb816fbde9e Mon Sep 17 00:00:00 2001
From: Alexander Nozik <altavir@gmail.com>
Date: Sat, 13 Mar 2021 21:22:18 +0300
Subject: [PATCH 25/37] Vector space refactor

---
 kmath-core/api/kmath-core.api                 | 327 ++++--------------
 .../kscience/kmath/linear/MatrixBuilder.kt    |  12 +-
 .../kscience/kmath/linear/VirtualMatrix.kt    |  10 +-
 .../space/kscience/kmath/nd/Structure2D.kt    |  11 +-
 .../space/kscience/kmath/linear/MatrixTest.kt |   2 +
 .../kscience/kmath/linear/RealLUSolverTest.kt |   8 +-
 .../space/kscience/kmath/real/RealMatrix.kt   |   4 +
 .../kaceince/kmath/real/RealMatrixTest.kt     |  31 +-
 8 files changed, 105 insertions(+), 300 deletions(-)

diff --git a/kmath-core/api/kmath-core.api b/kmath-core/api/kmath-core.api
index 8b30e4c05..c1f8d5ec5 100644
--- a/kmath-core/api/kmath-core.api
+++ b/kmath-core/api/kmath-core.api
@@ -432,108 +432,6 @@ public final class space/kscience/kmath/expressions/SymbolIndexerKt {
 	public static final fun withSymbols ([Lspace/kscience/kmath/expressions/Symbol;Lkotlin/jvm/functions/Function1;)Ljava/lang/Object;
 }
 
-public final class space/kscience/kmath/linear/BufferMatrix : space/kscience/kmath/nd/Structure2D {
-	public fun <init> (IILspace/kscience/kmath/structures/Buffer;)V
-	public fun elements ()Lkotlin/sequences/Sequence;
-	public fun equals (Ljava/lang/Object;)Z
-	public fun get (II)Ljava/lang/Object;
-	public fun get ([I)Ljava/lang/Object;
-	public final fun getBuffer ()Lspace/kscience/kmath/structures/Buffer;
-	public fun getColNum ()I
-	public fun getColumns ()Lspace/kscience/kmath/structures/Buffer;
-	public fun getDimension ()I
-	public fun getRowNum ()I
-	public fun getRows ()Lspace/kscience/kmath/structures/Buffer;
-	public fun getShape ()[I
-	public fun hashCode ()I
-	public fun toString ()Ljava/lang/String;
-}
-
-public final class space/kscience/kmath/linear/BufferMatrixContext : space/kscience/kmath/linear/GenericMatrixContext {
-	public static final field Companion Lspace/kscience/kmath/linear/BufferMatrixContext$Companion;
-	public fun <init> (Lspace/kscience/kmath/operations/Ring;Lkotlin/jvm/functions/Function2;)V
-	public synthetic fun add (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun add (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/linear/BufferMatrix;
-	public synthetic fun add (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public synthetic fun binaryOperation (Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun binaryOperation (Ljava/lang/String;Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public fun binaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
-	public synthetic fun bindSymbol (Ljava/lang/String;)Ljava/lang/Object;
-	public fun bindSymbol (Ljava/lang/String;)Lspace/kscience/kmath/nd/Structure2D;
-	public synthetic fun div (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
-	public fun div (Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Number;)Lspace/kscience/kmath/nd/Structure2D;
-	public fun dot (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/linear/BufferMatrix;
-	public synthetic fun dot (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public fun dot (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-	public fun getElementContext ()Lspace/kscience/kmath/operations/Ring;
-	public synthetic fun minus (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun minus (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/linear/BufferMatrix;
-	public synthetic fun minus (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public final fun one (II)Lspace/kscience/kmath/nd/Structure2D;
-	public synthetic fun plus (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun plus (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public fun point (ILkotlin/jvm/functions/Function1;)Lspace/kscience/kmath/structures/Buffer;
-	public fun produce (IILkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/linear/BufferMatrix;
-	public synthetic fun produce (IILkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/nd/Structure2D;
-	public synthetic fun scale (Ljava/lang/Object;D)Ljava/lang/Object;
-	public fun scale (Lspace/kscience/kmath/nd/Structure2D;D)Lspace/kscience/kmath/nd/Structure2D;
-	public synthetic fun times (Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun times (Ljava/lang/Number;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public synthetic fun times (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
-	public fun times (Ljava/lang/Object;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/linear/BufferMatrix;
-	public synthetic fun times (Ljava/lang/Object;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public fun times (Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Number;)Lspace/kscience/kmath/nd/Structure2D;
-	public fun times (Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Object;)Lspace/kscience/kmath/linear/BufferMatrix;
-	public synthetic fun times (Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Object;)Lspace/kscience/kmath/nd/Structure2D;
-	public synthetic fun unaryMinus (Ljava/lang/Object;)Ljava/lang/Object;
-	public fun unaryMinus (Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/linear/BufferMatrix;
-	public synthetic fun unaryMinus (Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public synthetic fun unaryOperation (Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun unaryOperation (Ljava/lang/String;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public fun unaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
-	public synthetic fun unaryPlus (Ljava/lang/Object;)Ljava/lang/Object;
-	public fun unaryPlus (Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-}
-
-public final class space/kscience/kmath/linear/BufferMatrixContext$Companion {
-}
-
-public final class space/kscience/kmath/linear/BufferVectorSpace : space/kscience/kmath/linear/VectorSpace {
-	public fun <init> (ILspace/kscience/kmath/operations/Group;Lkotlin/jvm/functions/Function2;)V
-	public synthetic fun add (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun add (Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-	public synthetic fun binaryOperation (Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun binaryOperation (Ljava/lang/String;Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-	public fun binaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
-	public synthetic fun bindSymbol (Ljava/lang/String;)Ljava/lang/Object;
-	public fun bindSymbol (Ljava/lang/String;)Lspace/kscience/kmath/structures/Buffer;
-	public synthetic fun div (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
-	public fun div (Lspace/kscience/kmath/structures/Buffer;Ljava/lang/Number;)Lspace/kscience/kmath/structures/Buffer;
-	public fun getAlgebra ()Lspace/kscience/kmath/operations/Group;
-	public final fun getBufferFactory ()Lkotlin/jvm/functions/Function2;
-	public fun getSize ()I
-	public synthetic fun getZero ()Ljava/lang/Object;
-	public fun getZero ()Lspace/kscience/kmath/structures/Buffer;
-	public synthetic fun minus (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun minus (Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-	public synthetic fun plus (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun plus (Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-	public fun produce (Lkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/structures/Buffer;
-	public synthetic fun scale (Ljava/lang/Object;D)Ljava/lang/Object;
-	public fun scale (Lspace/kscience/kmath/structures/Buffer;D)Lspace/kscience/kmath/structures/Buffer;
-	public synthetic fun times (Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun times (Ljava/lang/Number;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-	public synthetic fun times (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
-	public fun times (Lspace/kscience/kmath/structures/Buffer;Ljava/lang/Number;)Lspace/kscience/kmath/structures/Buffer;
-	public synthetic fun unaryMinus (Ljava/lang/Object;)Ljava/lang/Object;
-	public fun unaryMinus (Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-	public synthetic fun unaryOperation (Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun unaryOperation (Ljava/lang/String;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-	public fun unaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
-	public synthetic fun unaryPlus (Ljava/lang/Object;)Ljava/lang/Object;
-	public fun unaryPlus (Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-}
-
 public abstract interface class space/kscience/kmath/linear/CholeskyDecompositionFeature : space/kscience/kmath/linear/MatrixFeature {
 	public abstract fun getL ()Lspace/kscience/kmath/nd/Structure2D;
 }
@@ -549,37 +447,6 @@ public abstract interface class space/kscience/kmath/linear/DiagonalFeature : sp
 public final class space/kscience/kmath/linear/DiagonalFeature$Companion : space/kscience/kmath/linear/DiagonalFeature {
 }
 
-public abstract interface class space/kscience/kmath/linear/GenericMatrixContext : space/kscience/kmath/linear/MatrixContext {
-	public abstract fun add (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public abstract fun dot (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public abstract fun dot (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-	public abstract fun getElementContext ()Lspace/kscience/kmath/operations/Ring;
-	public abstract fun minus (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public abstract fun times (Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Object;)Lspace/kscience/kmath/nd/Structure2D;
-	public abstract fun unaryMinus (Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-}
-
-public final class space/kscience/kmath/linear/GenericMatrixContext$DefaultImpls {
-	public static fun add (Lspace/kscience/kmath/linear/GenericMatrixContext;Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public static fun binaryOperation (Lspace/kscience/kmath/linear/GenericMatrixContext;Ljava/lang/String;Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public static fun binaryOperationFunction (Lspace/kscience/kmath/linear/GenericMatrixContext;Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
-	public static fun bindSymbol (Lspace/kscience/kmath/linear/GenericMatrixContext;Ljava/lang/String;)Lspace/kscience/kmath/nd/Structure2D;
-	public static fun div (Lspace/kscience/kmath/linear/GenericMatrixContext;Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Number;)Lspace/kscience/kmath/nd/Structure2D;
-	public static fun dot (Lspace/kscience/kmath/linear/GenericMatrixContext;Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public static fun dot (Lspace/kscience/kmath/linear/GenericMatrixContext;Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-	public static fun minus (Lspace/kscience/kmath/linear/GenericMatrixContext;Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public static fun plus (Lspace/kscience/kmath/linear/GenericMatrixContext;Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public static fun point (Lspace/kscience/kmath/linear/GenericMatrixContext;ILkotlin/jvm/functions/Function1;)Lspace/kscience/kmath/structures/Buffer;
-	public static fun times (Lspace/kscience/kmath/linear/GenericMatrixContext;Ljava/lang/Number;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public static fun times (Lspace/kscience/kmath/linear/GenericMatrixContext;Ljava/lang/Object;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public static fun times (Lspace/kscience/kmath/linear/GenericMatrixContext;Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Number;)Lspace/kscience/kmath/nd/Structure2D;
-	public static fun times (Lspace/kscience/kmath/linear/GenericMatrixContext;Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Object;)Lspace/kscience/kmath/nd/Structure2D;
-	public static fun unaryMinus (Lspace/kscience/kmath/linear/GenericMatrixContext;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public static fun unaryOperation (Lspace/kscience/kmath/linear/GenericMatrixContext;Ljava/lang/String;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public static fun unaryOperationFunction (Lspace/kscience/kmath/linear/GenericMatrixContext;Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
-	public static fun unaryPlus (Lspace/kscience/kmath/linear/GenericMatrixContext;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-}
-
 public abstract interface class space/kscience/kmath/linear/InverseMatrixFeature : space/kscience/kmath/linear/MatrixFeature {
 	public abstract fun getInverse ()Lspace/kscience/kmath/nd/Structure2D;
 }
@@ -590,7 +457,7 @@ public final class space/kscience/kmath/linear/LFeature : space/kscience/kmath/l
 
 public final class space/kscience/kmath/linear/LinearAlgebraKt {
 	public static final fun asMatrix (Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/linear/VirtualMatrix;
-	public static final fun asPoint (Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/structures/Buffer;
+	public static final fun asVector (Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/structures/Buffer;
 }
 
 public abstract interface class space/kscience/kmath/linear/LinearSolver {
@@ -603,9 +470,50 @@ public final class space/kscience/kmath/linear/LinearSolver$DefaultImpls {
 	public static fun solve (Lspace/kscience/kmath/linear/LinearSolver;Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
 }
 
+public abstract interface class space/kscience/kmath/linear/LinearSpace {
+	public static final field Companion Lspace/kscience/kmath/linear/LinearSpace$Companion;
+	public abstract fun buildMatrix (IILkotlin/jvm/functions/Function3;)Lspace/kscience/kmath/nd/Structure2D;
+	public abstract fun buildVector (ILkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/structures/Buffer;
+	public abstract fun dot (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
+	public abstract fun dot (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
+	public abstract fun getElementAlgebra ()Lspace/kscience/kmath/operations/Ring;
+	public abstract fun minus (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
+	public abstract fun minus (Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
+	public abstract fun plus (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
+	public abstract fun plus (Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
+	public abstract fun times (Ljava/lang/Object;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
+	public abstract fun times (Ljava/lang/Object;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
+	public abstract fun times (Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Object;)Lspace/kscience/kmath/nd/Structure2D;
+	public abstract fun times (Lspace/kscience/kmath/structures/Buffer;Ljava/lang/Object;)Lspace/kscience/kmath/structures/Buffer;
+	public abstract fun unaryMinus (Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
+	public abstract fun unaryMinus (Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
+}
+
+public final class space/kscience/kmath/linear/LinearSpace$Companion {
+	public final fun buffered (Lspace/kscience/kmath/operations/Ring;Lkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/linear/LinearSpace;
+	public static synthetic fun buffered$default (Lspace/kscience/kmath/linear/LinearSpace$Companion;Lspace/kscience/kmath/operations/Ring;Lkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lspace/kscience/kmath/linear/LinearSpace;
+	public final fun getReal ()Lspace/kscience/kmath/linear/LinearSpace;
+}
+
+public final class space/kscience/kmath/linear/LinearSpace$DefaultImpls {
+	public static fun buildVector (Lspace/kscience/kmath/linear/LinearSpace;ILkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/structures/Buffer;
+	public static fun dot (Lspace/kscience/kmath/linear/LinearSpace;Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
+	public static fun dot (Lspace/kscience/kmath/linear/LinearSpace;Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
+	public static fun minus (Lspace/kscience/kmath/linear/LinearSpace;Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
+	public static fun minus (Lspace/kscience/kmath/linear/LinearSpace;Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
+	public static fun plus (Lspace/kscience/kmath/linear/LinearSpace;Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
+	public static fun plus (Lspace/kscience/kmath/linear/LinearSpace;Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
+	public static fun times (Lspace/kscience/kmath/linear/LinearSpace;Ljava/lang/Object;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
+	public static fun times (Lspace/kscience/kmath/linear/LinearSpace;Ljava/lang/Object;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
+	public static fun times (Lspace/kscience/kmath/linear/LinearSpace;Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Object;)Lspace/kscience/kmath/nd/Structure2D;
+	public static fun times (Lspace/kscience/kmath/linear/LinearSpace;Lspace/kscience/kmath/structures/Buffer;Ljava/lang/Object;)Lspace/kscience/kmath/structures/Buffer;
+	public static fun unaryMinus (Lspace/kscience/kmath/linear/LinearSpace;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
+	public static fun unaryMinus (Lspace/kscience/kmath/linear/LinearSpace;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
+}
+
 public final class space/kscience/kmath/linear/LupDecomposition : space/kscience/kmath/linear/DeterminantFeature, space/kscience/kmath/linear/LupDecompositionFeature {
-	public fun <init> (Lspace/kscience/kmath/linear/MatrixContext;Lspace/kscience/kmath/operations/Field;Lspace/kscience/kmath/nd/Structure2D;[IZ)V
-	public final fun getContext ()Lspace/kscience/kmath/linear/MatrixContext;
+	public fun <init> (Lspace/kscience/kmath/linear/LinearSpace;Lspace/kscience/kmath/operations/Field;Lspace/kscience/kmath/nd/Structure2D;[IZ)V
+	public final fun getContext ()Lspace/kscience/kmath/linear/LinearSpace;
 	public fun getDeterminant ()Ljava/lang/Object;
 	public final fun getElementContext ()Lspace/kscience/kmath/operations/Field;
 	public fun getL ()Lspace/kscience/kmath/nd/Structure2D;
@@ -622,57 +530,27 @@ public abstract interface class space/kscience/kmath/linear/LupDecompositionFeat
 }
 
 public final class space/kscience/kmath/linear/LupDecompositionKt {
-	public static final fun abs (Lspace/kscience/kmath/linear/GenericMatrixContext;Ljava/lang/Comparable;)Ljava/lang/Comparable;
-	public static final fun inverseWithLup (Lspace/kscience/kmath/linear/RealMatrixContext;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public static final fun lup (Lspace/kscience/kmath/linear/MatrixContext;Lkotlin/jvm/functions/Function2;Lspace/kscience/kmath/operations/Field;Lspace/kscience/kmath/nd/Structure2D;Lkotlin/jvm/functions/Function1;)Lspace/kscience/kmath/linear/LupDecomposition;
-	public static final fun lup (Lspace/kscience/kmath/linear/MatrixContext;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/linear/LupDecomposition;
+	public static final fun abs (Lspace/kscience/kmath/linear/LinearSpace;Ljava/lang/Comparable;)Ljava/lang/Comparable;
+	public static final fun inverseWithLup (Lspace/kscience/kmath/linear/LinearSpace;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
+	public static final fun lup (Lspace/kscience/kmath/linear/LinearSpace;Lkotlin/jvm/functions/Function2;Lspace/kscience/kmath/nd/Structure2D;Lkotlin/jvm/functions/Function1;)Lspace/kscience/kmath/linear/LupDecomposition;
+	public static final fun lup (Lspace/kscience/kmath/linear/LinearSpace;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/linear/LupDecomposition;
+	public static final fun solveWithLup (Lspace/kscience/kmath/linear/LinearSpace;Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
 	public static final fun solveWithLup (Lspace/kscience/kmath/linear/LupDecomposition;Lkotlin/jvm/functions/Function2;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public static final fun solveWithLup (Lspace/kscience/kmath/linear/RealMatrixContext;Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
 }
 
 public final class space/kscience/kmath/linear/MatrixBuilder {
-	public fun <init> (II)V
+	public fun <init> (Lspace/kscience/kmath/linear/LinearSpace;II)V
 	public final fun getColumns ()I
+	public final fun getLinearSpace ()Lspace/kscience/kmath/linear/LinearSpace;
 	public final fun getRows ()I
 	public final fun invoke ([Ljava/lang/Object;)Lspace/kscience/kmath/nd/Structure2D;
 }
 
 public final class space/kscience/kmath/linear/MatrixBuilderKt {
-	public static final fun build (Lspace/kscience/kmath/nd/Structure2D$Companion;II)Lspace/kscience/kmath/linear/MatrixBuilder;
-	public static final fun column (Lspace/kscience/kmath/nd/Structure2D$Companion;[Ljava/lang/Object;)Lspace/kscience/kmath/nd/Structure2D;
-	public static final fun row (Lspace/kscience/kmath/nd/Structure2D$Companion;[Ljava/lang/Object;)Lspace/kscience/kmath/nd/Structure2D;
-}
-
-public abstract interface class space/kscience/kmath/linear/MatrixContext : space/kscience/kmath/operations/GroupOperations, space/kscience/kmath/operations/ScaleOperations {
-	public static final field Companion Lspace/kscience/kmath/linear/MatrixContext$Companion;
-	public abstract fun binaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
-	public abstract fun dot (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public abstract fun dot (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-	public abstract fun point (ILkotlin/jvm/functions/Function1;)Lspace/kscience/kmath/structures/Buffer;
-	public abstract fun produce (IILkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/nd/Structure2D;
-	public abstract fun times (Ljava/lang/Object;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public abstract fun times (Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Object;)Lspace/kscience/kmath/nd/Structure2D;
-}
-
-public final class space/kscience/kmath/linear/MatrixContext$Companion {
-	public final fun buffered (Lspace/kscience/kmath/operations/Ring;Lkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/linear/GenericMatrixContext;
-	public static synthetic fun buffered$default (Lspace/kscience/kmath/linear/MatrixContext$Companion;Lspace/kscience/kmath/operations/Ring;Lkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lspace/kscience/kmath/linear/GenericMatrixContext;
-}
-
-public final class space/kscience/kmath/linear/MatrixContext$DefaultImpls {
-	public static fun binaryOperation (Lspace/kscience/kmath/linear/MatrixContext;Ljava/lang/String;Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public static fun binaryOperationFunction (Lspace/kscience/kmath/linear/MatrixContext;Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
-	public static fun bindSymbol (Lspace/kscience/kmath/linear/MatrixContext;Ljava/lang/String;)Lspace/kscience/kmath/nd/Structure2D;
-	public static fun div (Lspace/kscience/kmath/linear/MatrixContext;Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Number;)Lspace/kscience/kmath/nd/Structure2D;
-	public static fun minus (Lspace/kscience/kmath/linear/MatrixContext;Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public static fun plus (Lspace/kscience/kmath/linear/MatrixContext;Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public static fun point (Lspace/kscience/kmath/linear/MatrixContext;ILkotlin/jvm/functions/Function1;)Lspace/kscience/kmath/structures/Buffer;
-	public static fun times (Lspace/kscience/kmath/linear/MatrixContext;Ljava/lang/Number;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public static fun times (Lspace/kscience/kmath/linear/MatrixContext;Ljava/lang/Object;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public static fun times (Lspace/kscience/kmath/linear/MatrixContext;Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Number;)Lspace/kscience/kmath/nd/Structure2D;
-	public static fun unaryOperation (Lspace/kscience/kmath/linear/MatrixContext;Ljava/lang/String;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public static fun unaryOperationFunction (Lspace/kscience/kmath/linear/MatrixContext;Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
-	public static fun unaryPlus (Lspace/kscience/kmath/linear/MatrixContext;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
+	public static final fun column (Lspace/kscience/kmath/linear/LinearSpace;ILkotlin/jvm/functions/Function1;)Lspace/kscience/kmath/nd/Structure2D;
+	public static final fun column (Lspace/kscience/kmath/linear/LinearSpace;[Ljava/lang/Object;)Lspace/kscience/kmath/nd/Structure2D;
+	public static final fun row (Lspace/kscience/kmath/linear/LinearSpace;ILkotlin/jvm/functions/Function1;)Lspace/kscience/kmath/nd/Structure2D;
+	public static final fun row (Lspace/kscience/kmath/linear/LinearSpace;[Ljava/lang/Object;)Lspace/kscience/kmath/nd/Structure2D;
 }
 
 public abstract interface class space/kscience/kmath/linear/MatrixFeature {
@@ -701,12 +579,11 @@ public final class space/kscience/kmath/linear/MatrixWrapper : space/kscience/km
 
 public final class space/kscience/kmath/linear/MatrixWrapperKt {
 	public static final fun getOrigin (Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public static final fun one (Lspace/kscience/kmath/linear/GenericMatrixContext;II)Lspace/kscience/kmath/nd/Structure2D;
+	public static final fun one (Lspace/kscience/kmath/linear/LinearSpace;II)Lspace/kscience/kmath/nd/Structure2D;
 	public static final fun plus (Lspace/kscience/kmath/nd/Structure2D;Ljava/util/Collection;)Lspace/kscience/kmath/linear/MatrixWrapper;
 	public static final fun plus (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/linear/MatrixFeature;)Lspace/kscience/kmath/linear/MatrixWrapper;
-	public static final fun square (Lspace/kscience/kmath/nd/Structure2D$Companion;[Ljava/lang/Object;)Lspace/kscience/kmath/nd/Structure2D;
 	public static final fun transpose (Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public static final fun zero (Lspace/kscience/kmath/linear/GenericMatrixContext;II)Lspace/kscience/kmath/nd/Structure2D;
+	public static final fun zero (Lspace/kscience/kmath/linear/LinearSpace;II)Lspace/kscience/kmath/nd/Structure2D;
 }
 
 public final class space/kscience/kmath/linear/OrthogonalFeature : space/kscience/kmath/linear/MatrixFeature {
@@ -718,52 +595,6 @@ public abstract interface class space/kscience/kmath/linear/QRDecompositionFeatu
 	public abstract fun getR ()Lspace/kscience/kmath/nd/Structure2D;
 }
 
-public final class space/kscience/kmath/linear/RealMatrixContext : space/kscience/kmath/linear/MatrixContext, space/kscience/kmath/operations/ScaleOperations {
-	public static final field INSTANCE Lspace/kscience/kmath/linear/RealMatrixContext;
-	public synthetic fun add (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun add (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/linear/BufferMatrix;
-	public synthetic fun binaryOperation (Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun binaryOperation (Ljava/lang/String;Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public fun binaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
-	public synthetic fun bindSymbol (Ljava/lang/String;)Ljava/lang/Object;
-	public fun bindSymbol (Ljava/lang/String;)Lspace/kscience/kmath/nd/Structure2D;
-	public synthetic fun div (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
-	public fun div (Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Number;)Lspace/kscience/kmath/nd/Structure2D;
-	public fun dot (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/linear/BufferMatrix;
-	public synthetic fun dot (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public fun dot (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-	public synthetic fun minus (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun minus (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public final fun one (II)Lspace/kscience/kmath/nd/Structure2D;
-	public synthetic fun plus (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun plus (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public fun point (ILkotlin/jvm/functions/Function1;)Lspace/kscience/kmath/structures/Buffer;
-	public fun produce (IILkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/linear/BufferMatrix;
-	public synthetic fun produce (IILkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/nd/Structure2D;
-	public synthetic fun scale (Ljava/lang/Object;D)Ljava/lang/Object;
-	public fun scale (Lspace/kscience/kmath/nd/Structure2D;D)Lspace/kscience/kmath/linear/BufferMatrix;
-	public fun times (DLspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/linear/BufferMatrix;
-	public synthetic fun times (Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun times (Ljava/lang/Number;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public synthetic fun times (Ljava/lang/Object;Ljava/lang/Number;)Ljava/lang/Object;
-	public synthetic fun times (Ljava/lang/Object;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public fun times (Lspace/kscience/kmath/nd/Structure2D;D)Lspace/kscience/kmath/linear/BufferMatrix;
-	public fun times (Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Number;)Lspace/kscience/kmath/nd/Structure2D;
-	public synthetic fun times (Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Object;)Lspace/kscience/kmath/nd/Structure2D;
-	public final fun toBufferMatrix (Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/linear/BufferMatrix;
-	public synthetic fun unaryMinus (Ljava/lang/Object;)Ljava/lang/Object;
-	public fun unaryMinus (Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public synthetic fun unaryOperation (Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun unaryOperation (Ljava/lang/String;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public fun unaryOperationFunction (Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
-	public synthetic fun unaryPlus (Ljava/lang/Object;)Ljava/lang/Object;
-	public fun unaryPlus (Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-}
-
-public final class space/kscience/kmath/linear/RealMatrixContextKt {
-	public static final fun getReal (Lspace/kscience/kmath/linear/MatrixContext$Companion;)Lspace/kscience/kmath/linear/RealMatrixContext;
-}
-
 public abstract interface class space/kscience/kmath/linear/SingularValueDecompositionFeature : space/kscience/kmath/linear/MatrixFeature {
 	public abstract fun getS ()Lspace/kscience/kmath/nd/Structure2D;
 	public abstract fun getSingularValues ()Lspace/kscience/kmath/structures/Buffer;
@@ -784,41 +615,6 @@ public final class space/kscience/kmath/linear/UnitFeature : space/kscience/kmat
 	public static final field INSTANCE Lspace/kscience/kmath/linear/UnitFeature;
 }
 
-public abstract interface class space/kscience/kmath/linear/VectorSpace : space/kscience/kmath/operations/Group, space/kscience/kmath/operations/ScaleOperations {
-	public static final field Companion Lspace/kscience/kmath/linear/VectorSpace$Companion;
-	public abstract fun add (Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-	public abstract fun getAlgebra ()Lspace/kscience/kmath/operations/Group;
-	public abstract fun getSize ()I
-	public abstract fun getZero ()Lspace/kscience/kmath/structures/Buffer;
-	public abstract fun produce (Lkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/structures/Buffer;
-	public abstract fun scale (Lspace/kscience/kmath/structures/Buffer;D)Lspace/kscience/kmath/structures/Buffer;
-	public abstract fun unaryMinus (Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-}
-
-public final class space/kscience/kmath/linear/VectorSpace$Companion {
-	public final fun buffered (ILspace/kscience/kmath/operations/Group;Lkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/linear/BufferVectorSpace;
-	public static synthetic fun buffered$default (Lspace/kscience/kmath/linear/VectorSpace$Companion;ILspace/kscience/kmath/operations/Group;Lkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lspace/kscience/kmath/linear/BufferVectorSpace;
-	public final fun real (I)Lspace/kscience/kmath/linear/BufferVectorSpace;
-}
-
-public final class space/kscience/kmath/linear/VectorSpace$DefaultImpls {
-	public static fun add (Lspace/kscience/kmath/linear/VectorSpace;Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-	public static fun binaryOperation (Lspace/kscience/kmath/linear/VectorSpace;Ljava/lang/String;Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-	public static fun binaryOperationFunction (Lspace/kscience/kmath/linear/VectorSpace;Ljava/lang/String;)Lkotlin/jvm/functions/Function2;
-	public static fun bindSymbol (Lspace/kscience/kmath/linear/VectorSpace;Ljava/lang/String;)Lspace/kscience/kmath/structures/Buffer;
-	public static fun div (Lspace/kscience/kmath/linear/VectorSpace;Lspace/kscience/kmath/structures/Buffer;Ljava/lang/Number;)Lspace/kscience/kmath/structures/Buffer;
-	public static fun getZero (Lspace/kscience/kmath/linear/VectorSpace;)Lspace/kscience/kmath/structures/Buffer;
-	public static fun minus (Lspace/kscience/kmath/linear/VectorSpace;Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-	public static fun plus (Lspace/kscience/kmath/linear/VectorSpace;Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-	public static fun scale (Lspace/kscience/kmath/linear/VectorSpace;Lspace/kscience/kmath/structures/Buffer;D)Lspace/kscience/kmath/structures/Buffer;
-	public static fun times (Lspace/kscience/kmath/linear/VectorSpace;Ljava/lang/Number;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-	public static fun times (Lspace/kscience/kmath/linear/VectorSpace;Lspace/kscience/kmath/structures/Buffer;Ljava/lang/Number;)Lspace/kscience/kmath/structures/Buffer;
-	public static fun unaryMinus (Lspace/kscience/kmath/linear/VectorSpace;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-	public static fun unaryOperation (Lspace/kscience/kmath/linear/VectorSpace;Ljava/lang/String;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-	public static fun unaryOperationFunction (Lspace/kscience/kmath/linear/VectorSpace;Ljava/lang/String;)Lkotlin/jvm/functions/Function1;
-	public static fun unaryPlus (Lspace/kscience/kmath/linear/VectorSpace;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-}
-
 public final class space/kscience/kmath/linear/VirtualMatrix : space/kscience/kmath/nd/Structure2D {
 	public fun <init> (IILkotlin/jvm/functions/Function2;)V
 	public fun elements ()Lkotlin/sequences/Sequence;
@@ -1147,10 +943,10 @@ public abstract interface class space/kscience/kmath/nd/NDStructure {
 public final class space/kscience/kmath/nd/NDStructure$Companion {
 	public final fun auto (Lkotlin/reflect/KClass;Lspace/kscience/kmath/nd/Strides;Lkotlin/jvm/functions/Function1;)Lspace/kscience/kmath/nd/NDBuffer;
 	public final fun auto (Lkotlin/reflect/KClass;[ILkotlin/jvm/functions/Function1;)Lspace/kscience/kmath/nd/NDBuffer;
-	public final fun build (Lspace/kscience/kmath/nd/Strides;Lkotlin/jvm/functions/Function2;Lkotlin/jvm/functions/Function1;)Lspace/kscience/kmath/nd/NDBuffer;
-	public final fun build ([ILkotlin/jvm/functions/Function2;Lkotlin/jvm/functions/Function1;)Lspace/kscience/kmath/nd/NDBuffer;
-	public static synthetic fun build$default (Lspace/kscience/kmath/nd/NDStructure$Companion;Lspace/kscience/kmath/nd/Strides;Lkotlin/jvm/functions/Function2;Lkotlin/jvm/functions/Function1;ILjava/lang/Object;)Lspace/kscience/kmath/nd/NDBuffer;
-	public static synthetic fun build$default (Lspace/kscience/kmath/nd/NDStructure$Companion;[ILkotlin/jvm/functions/Function2;Lkotlin/jvm/functions/Function1;ILjava/lang/Object;)Lspace/kscience/kmath/nd/NDBuffer;
+	public final fun buffered (Lspace/kscience/kmath/nd/Strides;Lkotlin/jvm/functions/Function2;Lkotlin/jvm/functions/Function1;)Lspace/kscience/kmath/nd/NDBuffer;
+	public final fun buffered ([ILkotlin/jvm/functions/Function2;Lkotlin/jvm/functions/Function1;)Lspace/kscience/kmath/nd/NDBuffer;
+	public static synthetic fun buffered$default (Lspace/kscience/kmath/nd/NDStructure$Companion;Lspace/kscience/kmath/nd/Strides;Lkotlin/jvm/functions/Function2;Lkotlin/jvm/functions/Function1;ILjava/lang/Object;)Lspace/kscience/kmath/nd/NDBuffer;
+	public static synthetic fun buffered$default (Lspace/kscience/kmath/nd/NDStructure$Companion;[ILkotlin/jvm/functions/Function2;Lkotlin/jvm/functions/Function1;ILjava/lang/Object;)Lspace/kscience/kmath/nd/NDBuffer;
 	public final fun contentEquals (Lspace/kscience/kmath/nd/NDStructure;Lspace/kscience/kmath/nd/NDStructure;)Z
 }
 
@@ -1314,7 +1110,6 @@ public abstract interface class space/kscience/kmath/nd/Structure2D : space/ksci
 }
 
 public final class space/kscience/kmath/nd/Structure2D$Companion {
-	public final fun real (IILkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/linear/BufferMatrix;
 }
 
 public final class space/kscience/kmath/nd/Structure2D$DefaultImpls {
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixBuilder.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixBuilder.kt
index 6814cb561..0a7f280bc 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixBuilder.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixBuilder.kt
@@ -16,19 +16,13 @@ public class MatrixBuilder<T : Any, A : Ring<T>>(
     //TODO add specific matrix builder functions like diagonal, etc
 }
 
+/**
+ * Create a matrix builder with given number of rows and columns
+ */
 @UnstableKMathAPI
 public fun <T : Any, A : Ring<T>> LinearSpace<T, A>.matrix(rows: Int, columns: Int): MatrixBuilder<T, A> =
     MatrixBuilder(this, rows, columns)
 
-/**
- * Build a square matrix from given elements.
- */
-@UnstableKMathAPI
-public fun <T : Any> LinearSpace<T, Ring<T>>.square(vararg elements: T): Matrix<T> {
-    val size: Int = kotlin.math.sqrt(elements.size.toDouble()).toInt()
-    return matrix(size,size)(*elements)
-}
-
 @UnstableKMathAPI
 public fun <T : Any> LinearSpace<T, Ring<T>>.vector(vararg elements: T): Vector<T> {
     return buildVector(elements.size) { elements[it] }
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/VirtualMatrix.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/VirtualMatrix.kt
index 11699ce2f..7f0451946 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/VirtualMatrix.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/VirtualMatrix.kt
@@ -1,5 +1,7 @@
 package space.kscience.kmath.linear
 
+import space.kscience.kmath.nd.NDStructure
+
 /**
  * The matrix where each element is evaluated each time when is being accessed.
  *
@@ -17,12 +19,8 @@ public class VirtualMatrix<T : Any>(
 
     override fun equals(other: Any?): Boolean {
         if (this === other) return true
-        if (other !is Matrix<*>) return false
-
-        if (rowNum != other.rowNum) return false
-        if (colNum != other.colNum) return false
-
-        return elements().all { (index, value) -> value == other[index] }
+        if (other !is NDStructure<*>) return false
+        return NDStructure.contentEquals(this, other)
     }
 
     override fun hashCode(): Int {
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/Structure2D.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/Structure2D.kt
index 0098eeb3b..09c830646 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/Structure2D.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/Structure2D.kt
@@ -1,7 +1,9 @@
 package space.kscience.kmath.nd
 
+import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.structures.Buffer
 import space.kscience.kmath.structures.VirtualBuffer
+import kotlin.reflect.KClass
 
 /**
  * A structure that is guaranteed to be two-dimensional.
@@ -58,7 +60,7 @@ public interface Structure2D<T> : NDStructure<T> {
 /**
  * A 2D wrapper for nd-structure
  */
-private inline class Structure2DWrapper<T>(val structure: NDStructure<T>) : Structure2D<T> {
+private class Structure2DWrapper<T>(val structure: NDStructure<T>) : Structure2D<T> {
     override val shape: IntArray get() = structure.shape
 
     override val rowNum: Int get() = shape[0]
@@ -66,7 +68,14 @@ private inline class Structure2DWrapper<T>(val structure: NDStructure<T>) : Stru
 
     override operator fun get(i: Int, j: Int): T = structure[i, j]
 
+    @UnstableKMathAPI
+    override fun <F : Any> getFeature(type: KClass<F>): F? = structure.getFeature(type)
+
     override fun elements(): Sequence<Pair<IntArray, T>> = structure.elements()
+
+    override fun equals(other: Any?): Boolean = structure == other
+
+    override fun hashCode(): Int  = structure.hashCode()
 }
 
 /**
diff --git a/kmath-core/src/commonTest/kotlin/space/kscience/kmath/linear/MatrixTest.kt b/kmath-core/src/commonTest/kotlin/space/kscience/kmath/linear/MatrixTest.kt
index 53cdd4522..097703f49 100644
--- a/kmath-core/src/commonTest/kotlin/space/kscience/kmath/linear/MatrixTest.kt
+++ b/kmath-core/src/commonTest/kotlin/space/kscience/kmath/linear/MatrixTest.kt
@@ -1,10 +1,12 @@
 package space.kscience.kmath.linear
 
+import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.nd.NDStructure
 import space.kscience.kmath.nd.as2D
 import kotlin.test.Test
 import kotlin.test.assertEquals
 
+@UnstableKMathAPI
 @Suppress("UNUSED_VARIABLE")
 class MatrixTest {
     @Test
diff --git a/kmath-core/src/commonTest/kotlin/space/kscience/kmath/linear/RealLUSolverTest.kt b/kmath-core/src/commonTest/kotlin/space/kscience/kmath/linear/RealLUSolverTest.kt
index 802849a1e..704f91998 100644
--- a/kmath-core/src/commonTest/kotlin/space/kscience/kmath/linear/RealLUSolverTest.kt
+++ b/kmath-core/src/commonTest/kotlin/space/kscience/kmath/linear/RealLUSolverTest.kt
@@ -1,8 +1,10 @@
 package space.kscience.kmath.linear
 
+import space.kscience.kmath.misc.UnstableKMathAPI
 import kotlin.test.Test
 import kotlin.test.assertEquals
 
+@UnstableKMathAPI
 class RealLUSolverTest {
 
     @Test
@@ -15,7 +17,7 @@ class RealLUSolverTest {
     @Test
     fun testDecomposition() {
         LinearSpace.real.run {
-            val matrix = square(
+            val matrix = matrix(2,2)(
                 3.0, 1.0,
                 1.0, 3.0
             )
@@ -31,14 +33,14 @@ class RealLUSolverTest {
 
     @Test
     fun testInvert() {
-        val matrix = LinearSpace.real.square(
+        val matrix = LinearSpace.real.matrix(2,2)(
             3.0, 1.0,
             1.0, 3.0
         )
 
         val inverted = LinearSpace.real.inverseWithLup(matrix)
 
-        val expected = LinearSpace.real.square(
+        val expected = LinearSpace.real.matrix(2,2)(
             0.375, -0.125,
             -0.125, 0.375
         )
diff --git a/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/RealMatrix.kt b/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/RealMatrix.kt
index 640615cc9..76c73ab16 100644
--- a/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/RealMatrix.kt
+++ b/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/RealMatrix.kt
@@ -25,6 +25,10 @@ public typealias RealMatrix = Matrix<Double>
 public fun realMatrix(rowNum: Int, colNum: Int, initializer: RealField.(i: Int, j: Int) -> Double): RealMatrix =
     LinearSpace.real.buildMatrix(rowNum, colNum, initializer)
 
+@OptIn(UnstableKMathAPI::class)
+public fun realMatrix(rowNum: Int, colNum: Int): MatrixBuilder<Double, RealField> =
+    LinearSpace.real.matrix(rowNum, colNum)
+
 public fun Array<DoubleArray>.toMatrix(): RealMatrix {
     return LinearSpace.real.buildMatrix(size, this[0].size) { row, col -> this@toMatrix[row][col] }
 }
diff --git a/kmath-for-real/src/commonTest/kotlin/kaceince/kmath/real/RealMatrixTest.kt b/kmath-for-real/src/commonTest/kotlin/kaceince/kmath/real/RealMatrixTest.kt
index 6ab11b03b..06135598e 100644
--- a/kmath-for-real/src/commonTest/kotlin/kaceince/kmath/real/RealMatrixTest.kt
+++ b/kmath-for-real/src/commonTest/kotlin/kaceince/kmath/real/RealMatrixTest.kt
@@ -9,6 +9,7 @@ import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertTrue
 
+@UnstableKMathAPI
 internal class RealMatrixTest {
     @Test
     fun testSum() {
@@ -30,11 +31,11 @@ internal class RealMatrixTest {
 
     @Test
     fun testRepeatStackVertical() {
-        val matrix1 = LinearSpace.real.matrix(2, 3)(
+        val matrix1 = realMatrix(2, 3)(
             1.0, 0.0, 0.0,
             0.0, 1.0, 2.0
         )
-        val matrix2 = LinearSpace.real.matrix(6, 3)(
+        val matrix2 = realMatrix(6, 3)(
             1.0, 0.0, 0.0,
             0.0, 1.0, 2.0,
             1.0, 0.0, 0.0,
@@ -47,7 +48,7 @@ internal class RealMatrixTest {
 
     @Test
     fun testMatrixAndDouble() {
-        val matrix1 = LinearSpace.real.matrix(2, 3)(
+        val matrix1 = realMatrix(2, 3)(
             1.0, 0.0, 3.0,
             4.0, 6.0, 2.0
         )
@@ -61,13 +62,13 @@ internal class RealMatrixTest {
 
     @Test
     fun testDoubleAndMatrix() {
-        val matrix1 = LinearSpace.real.matrix(2, 3)(
+        val matrix1 = realMatrix(2, 3)(
             1.0, 0.0, 3.0,
             4.0, 6.0, 2.0
         )
         val matrix2 = 20.0 - (10.0 + (5.0 * matrix1))
         //val matrix2 = 10.0 + (5.0 * matrix1)
-        val expectedResult = LinearSpace.real.matrix(2, 3)(
+        val expectedResult = realMatrix(2, 3)(
             5.0, 10.0, -5.0,
             -10.0, -20.0, 0.0
         )
@@ -76,15 +77,15 @@ internal class RealMatrixTest {
 
     @Test
     fun testSquareAndPower() {
-        val matrix1 = LinearSpace.real.matrix(2, 3)(
+        val matrix1 = realMatrix(2, 3)(
             -1.0, 0.0, 3.0,
             4.0, -6.0, -2.0
         )
-        val matrix2 = LinearSpace.real.matrix(2, 3)(
+        val matrix2 = realMatrix(2, 3)(
             1.0, 0.0, 9.0,
             16.0, 36.0, 4.0
         )
-        val matrix3 = LinearSpace.real.matrix(2, 3)(
+        val matrix3 = realMatrix(2, 3)(
             -1.0, 0.0, 27.0,
             64.0, -216.0, -8.0
         )
@@ -95,16 +96,16 @@ internal class RealMatrixTest {
     @OptIn(UnstableKMathAPI::class)
     @Test
     fun testTwoMatrixOperations() {
-        val matrix1 = LinearSpace.real.matrix(2, 3)(
+        val matrix1 = realMatrix(2, 3)(
             -1.0, 0.0, 3.0,
             4.0, -6.0, 7.0
         )
-        val matrix2 = LinearSpace.real.matrix(2, 3)(
+        val matrix2 = realMatrix(2, 3)(
             1.0, 0.0, 3.0,
             4.0, 6.0, -2.0
         )
         val result = matrix1 * matrix2 + matrix1 - matrix2
-        val expectedResult = LinearSpace.real.matrix(2, 3)(
+        val expectedResult = realMatrix(2, 3)(
             -3.0, 0.0, 9.0,
             16.0, -48.0, -5.0
         )
@@ -113,16 +114,16 @@ internal class RealMatrixTest {
 
     @Test
     fun testColumnOperations() {
-        val matrix1 = LinearSpace.real.matrix(2, 4)(
+        val matrix1 = realMatrix(2, 4)(
             -1.0, 0.0, 3.0, 15.0,
             4.0, -6.0, 7.0, -11.0
         )
-        val matrix2 = LinearSpace.real.matrix(2, 5)(
+        val matrix2 = realMatrix(2, 5)(
             -1.0, 0.0, 3.0, 15.0, -1.0,
             4.0, -6.0, 7.0, -11.0, 4.0
         )
-        val col1 = LinearSpace.real.matrix(2, 1)(0.0, -6.0)
-        val cols1to2 = LinearSpace.real.matrix(2, 2)(
+        val col1 = realMatrix(2, 1)(0.0, -6.0)
+        val cols1to2 = realMatrix(2, 2)(
             0.0, 3.0,
             -6.0, 7.0
         )
-- 
2.34.1


From 0aa73cd48fd0aa517189987ecbb0f011114d9a3e Mon Sep 17 00:00:00 2001
From: Alexander Nozik <altavir@gmail.com>
Date: Sun, 14 Mar 2021 09:43:22 +0300
Subject: [PATCH 26/37] Vector space refactor (optimization)

---
 examples/build.gradle.kts                     |  8 ++
 .../kscience/kmath/benchmarks/DotBenchmark.kt | 17 ++--
 .../ExpressionsInterpretersBenchmark.kt       |  4 +-
 ...Benchmark.kt => MatrixInverseBenchmark.kt} | 13 +--
 .../kmath/benchmarks/ViktorLogBenchmark.kt    |  4 +-
 .../space/kscience/kmath/ast/MstAlgebra.kt    |  6 +-
 kmath-core/api/kmath-core.api                 | 44 +++++++---
 .../kscience/kmath/linear/LinearSpace.kt      | 20 ++---
 .../kmath/linear/LinearSpaceOverNd.kt         | 85 +++++++++++++++++++
 .../kscience/kmath/nd/BufferNDAlgebra.kt      |  8 +-
 .../space/kscience/kmath/nd/Structure1D.kt    |  6 +-
 .../space/kscience/kmath/nd/Structure2D.kt    | 25 +++---
 .../kmath/structures/BufferAccessor2D.kt      |  4 +-
 .../kmath/structures/bufferOperation.kt       |  7 ++
 .../kscience/kmath/linear/RealLUSolverTest.kt |  4 +-
 .../kscience/kmath/ejml/EjmlLinearSpace.kt    |  8 +-
 .../kotlin/space/kscience/kmath/real/dot.kt   |  2 +-
 17 files changed, 183 insertions(+), 82 deletions(-)
 rename examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/{LinearAlgebraBenchmark.kt => MatrixInverseBenchmark.kt} (75%)
 create mode 100644 kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpaceOverNd.kt
 create mode 100644 kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/bufferOperation.kt

diff --git a/examples/build.gradle.kts b/examples/build.gradle.kts
index 77152dc0a..0301e4d67 100644
--- a/examples/build.gradle.kts
+++ b/examples/build.gradle.kts
@@ -92,6 +92,14 @@ benchmark {
         iterationTimeUnit = "ms" // time unity for iterationTime, default is seconds
         include("ExpressionsInterpretersBenchmark")
     }
+
+    configurations.register("matrixInverse") {
+        warmups = 1 // number of warmup iterations
+        iterations = 3 // number of iterations
+        iterationTime = 500 // time in seconds per iteration
+        iterationTimeUnit = "ms" // time unity for iterationTime, default is seconds
+        include("MatrixInverseBenchmark")
+    }
 }
 
 kotlin.sourceSets.all {
diff --git a/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/DotBenchmark.kt b/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/DotBenchmark.kt
index 8fb0c284e..dbf373929 100644
--- a/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/DotBenchmark.kt
+++ b/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/DotBenchmark.kt
@@ -6,12 +6,9 @@ import kotlinx.benchmark.Scope
 import kotlinx.benchmark.State
 import space.kscience.kmath.commons.linear.CMLinearSpace
 import space.kscience.kmath.ejml.EjmlLinearSpace
-import space.kscience.kmath.linear.BufferLinearSpace
-import space.kscience.kmath.linear.Matrix
-import space.kscience.kmath.linear.RealLinearSpace
+import space.kscience.kmath.linear.LinearSpace
+import space.kscience.kmath.linear.invoke
 import space.kscience.kmath.operations.RealField
-import space.kscience.kmath.operations.invoke
-import space.kscience.kmath.structures.Buffer
 import kotlin.random.Random
 
 @State(Scope.Benchmark)
@@ -21,8 +18,8 @@ internal class DotBenchmark {
         const val dim = 1000
 
         //creating invertible matrix
-        val matrix1 = Matrix.real(dim, dim) { i, j -> if (i <= j) random.nextDouble() else 0.0 }
-        val matrix2 = Matrix.real(dim, dim) { i, j -> if (i <= j) random.nextDouble() else 0.0 }
+        val matrix1 = LinearSpace.real.buildMatrix(dim, dim) { i, j -> if (i <= j) random.nextDouble() else 0.0 }
+        val matrix2 = LinearSpace.real.buildMatrix(dim, dim) { i, j -> if (i <= j) random.nextDouble() else 0.0 }
 
         val cmMatrix1 = CMLinearSpace { matrix1.toCM() }
         val cmMatrix2 = CMLinearSpace { matrix2.toCM() }
@@ -33,7 +30,7 @@ internal class DotBenchmark {
 
     @Benchmark
     fun cmDot(blackhole: Blackhole) {
-        CMLinearSpace {
+        CMLinearSpace.run {
             blackhole.consume(cmMatrix1 dot cmMatrix2)
         }
     }
@@ -54,14 +51,14 @@ internal class DotBenchmark {
 
     @Benchmark
     fun bufferedDot(blackhole: Blackhole) {
-        BufferLinearSpace(RealField, Buffer.Companion::real).invoke {
+        LinearSpace.auto(RealField).invoke {
             blackhole.consume(matrix1 dot matrix2)
         }
     }
 
     @Benchmark
     fun realDot(blackhole: Blackhole) {
-        RealLinearSpace {
+        LinearSpace.real {
             blackhole.consume(matrix1 dot matrix2)
         }
     }
diff --git a/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/ExpressionsInterpretersBenchmark.kt b/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/ExpressionsInterpretersBenchmark.kt
index 9c150f074..e5cfbf9f6 100644
--- a/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/ExpressionsInterpretersBenchmark.kt
+++ b/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/ExpressionsInterpretersBenchmark.kt
@@ -30,7 +30,7 @@ internal class ExpressionsInterpretersBenchmark {
     fun mstExpression(blackhole: Blackhole) {
         val expr = algebra.mstInField {
             val x = bindSymbol(x)
-            x * 2.0 + 2.0 / x - 16.0
+            x * 2.0 + number(2.0) / x - 16.0
         }
 
         invokeAndSum(expr, blackhole)
@@ -40,7 +40,7 @@ internal class ExpressionsInterpretersBenchmark {
     fun asmExpression(blackhole: Blackhole) {
         val expr = algebra.mstInField {
             val x = bindSymbol(x)
-            x * 2.0 + 2.0 / x - 16.0
+            x * 2.0 + number(2.0) / x - 16.0
         }.compile()
 
         invokeAndSum(expr, blackhole)
diff --git a/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/LinearAlgebraBenchmark.kt b/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/MatrixInverseBenchmark.kt
similarity index 75%
rename from examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/LinearAlgebraBenchmark.kt
rename to examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/MatrixInverseBenchmark.kt
index 85759d93c..7aa8ac975 100644
--- a/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/LinearAlgebraBenchmark.kt
+++ b/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/MatrixInverseBenchmark.kt
@@ -9,21 +9,22 @@ import space.kscience.kmath.commons.linear.inverse
 import space.kscience.kmath.ejml.EjmlLinearSpace
 import space.kscience.kmath.ejml.inverse
 import space.kscience.kmath.linear.LinearSpace
-import space.kscience.kmath.linear.Matrix
 import space.kscience.kmath.linear.inverseWithLup
-import space.kscience.kmath.linear.real
+import space.kscience.kmath.linear.invoke
 import kotlin.random.Random
 
 @State(Scope.Benchmark)
-internal class LinearAlgebraBenchmark {
+internal class MatrixInverseBenchmark {
     companion object {
         val random = Random(1224)
         const val dim = 100
 
+        private val space = LinearSpace.real
+
         //creating invertible matrix
-        val u = Matrix.real(dim, dim) { i, j -> if (i <= j) random.nextDouble() else 0.0 }
-        val l = Matrix.real(dim, dim) { i, j -> if (i >= j) random.nextDouble() else 0.0 }
-        val matrix = l dot u
+        val u = space.buildMatrix(dim, dim) { i, j -> if (i <= j) random.nextDouble() else 0.0 }
+        val l = space.buildMatrix(dim, dim) { i, j -> if (i >= j) random.nextDouble() else 0.0 }
+        val matrix = space { l dot u }
     }
 
     @Benchmark
diff --git a/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/ViktorLogBenchmark.kt b/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/ViktorLogBenchmark.kt
index c48c86af9..0036b615c 100644
--- a/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/ViktorLogBenchmark.kt
+++ b/examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/ViktorLogBenchmark.kt
@@ -15,7 +15,7 @@ import space.kscience.kmath.viktor.ViktorNDField
 internal class ViktorLogBenchmark {
     @Benchmark
     fun realFieldLog(blackhole: Blackhole) {
-        with(realField) {
+        with(realNdField) {
             val fortyTwo = produce { 42.0 }
             var res = one
             repeat(n) { res = ln(fortyTwo) }
@@ -47,7 +47,7 @@ internal class ViktorLogBenchmark {
 
         // automatically build context most suited for given type.
         private val autoField = NDAlgebra.auto(RealField, dim, dim)
-        private val realField = NDAlgebra.real(dim, dim)
+        private val realNdField = NDAlgebra.real(dim, dim)
         private val viktorField = ViktorNDField(intArrayOf(dim, dim))
     }
 }
diff --git a/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/MstAlgebra.kt b/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/MstAlgebra.kt
index 16fdfbeac..5ed39687b 100644
--- a/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/MstAlgebra.kt
+++ b/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/MstAlgebra.kt
@@ -54,7 +54,7 @@ public object MstRing : Ring<MST>, NumbersAddOperations<MST>, ScaleOperations<MS
     public override val one: MST.Numeric = number(1.0)
 
     public override fun number(value: Number): MST.Numeric = MstGroup.number(value)
-    public override fun bindSymbol(value: String): MST.Symbolic = MstGroup.bindSymbol(value)
+    public override fun bindSymbol(value: String): MST.Symbolic = MstAlgebra.bindSymbol(value)
     public override fun add(a: MST, b: MST): MST.Binary = MstGroup.add(a, b)
 
     public override fun scale(a: MST, value: Double): MST.Binary =
@@ -83,7 +83,7 @@ public object MstField : Field<MST>, NumbersAddOperations<MST>, ScaleOperations<
 
     public override val one: MST.Numeric get() = MstRing.one
 
-    public override fun bindSymbol(value: String): MST.Symbolic = MstRing.bindSymbol(value)
+    public override fun bindSymbol(value: String): MST.Symbolic = MstAlgebra.bindSymbol(value)
     public override fun number(value: Number): MST.Numeric = MstRing.number(value)
     public override fun add(a: MST, b: MST): MST.Binary = MstRing.add(a, b)
 
@@ -112,7 +112,7 @@ public object MstExtendedField : ExtendedField<MST>, NumericAlgebra<MST> {
     public override val zero: MST.Numeric get() = MstField.zero
     public override val one: MST.Numeric get() = MstField.one
 
-    public override fun bindSymbol(value: String): MST.Symbolic = MstField.bindSymbol(value)
+    public override fun bindSymbol(value: String): MST.Symbolic = MstAlgebra.bindSymbol(value)
     public override fun number(value: Number): MST.Numeric = MstRing.number(value)
     public override fun sin(arg: MST): MST.Unary = unaryOperationFunction(TrigonometricOperations.SIN_OPERATION)(arg)
     public override fun cos(arg: MST): MST.Unary = unaryOperationFunction(TrigonometricOperations.COS_OPERATION)(arg)
diff --git a/kmath-core/api/kmath-core.api b/kmath-core/api/kmath-core.api
index c1f8d5ec5..38da35d6c 100644
--- a/kmath-core/api/kmath-core.api
+++ b/kmath-core/api/kmath-core.api
@@ -496,7 +496,6 @@ public final class space/kscience/kmath/linear/LinearSpace$Companion {
 }
 
 public final class space/kscience/kmath/linear/LinearSpace$DefaultImpls {
-	public static fun buildVector (Lspace/kscience/kmath/linear/LinearSpace;ILkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/structures/Buffer;
 	public static fun dot (Lspace/kscience/kmath/linear/LinearSpace;Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
 	public static fun dot (Lspace/kscience/kmath/linear/LinearSpace;Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
 	public static fun minus (Lspace/kscience/kmath/linear/LinearSpace;Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
@@ -511,6 +510,29 @@ public final class space/kscience/kmath/linear/LinearSpace$DefaultImpls {
 	public static fun unaryMinus (Lspace/kscience/kmath/linear/LinearSpace;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
 }
 
+public final class space/kscience/kmath/linear/LinearSpaceKt {
+	public static final fun invoke (Lspace/kscience/kmath/linear/LinearSpace;Lkotlin/jvm/functions/Function1;)Ljava/lang/Object;
+}
+
+public final class space/kscience/kmath/linear/LinearSpaceOverNd : space/kscience/kmath/linear/LinearSpace {
+	public fun <init> (Lspace/kscience/kmath/operations/Ring;Lkotlin/jvm/functions/Function2;)V
+	public fun buildMatrix (IILkotlin/jvm/functions/Function3;)Lspace/kscience/kmath/nd/Structure2D;
+	public fun buildVector (ILkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/structures/Buffer;
+	public fun dot (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
+	public fun dot (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
+	public fun getElementAlgebra ()Lspace/kscience/kmath/operations/Ring;
+	public fun minus (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
+	public fun minus (Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
+	public fun plus (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
+	public fun plus (Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
+	public fun times (Ljava/lang/Object;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
+	public fun times (Ljava/lang/Object;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
+	public fun times (Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Object;)Lspace/kscience/kmath/nd/Structure2D;
+	public fun times (Lspace/kscience/kmath/structures/Buffer;Ljava/lang/Object;)Lspace/kscience/kmath/structures/Buffer;
+	public fun unaryMinus (Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
+	public fun unaryMinus (Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
+}
+
 public final class space/kscience/kmath/linear/LupDecomposition : space/kscience/kmath/linear/DeterminantFeature, space/kscience/kmath/linear/LupDecompositionFeature {
 	public fun <init> (Lspace/kscience/kmath/linear/LinearSpace;Lspace/kscience/kmath/operations/Field;Lspace/kscience/kmath/nd/Structure2D;[IZ)V
 	public final fun getContext ()Lspace/kscience/kmath/linear/LinearSpace;
@@ -566,12 +588,12 @@ public final class space/kscience/kmath/linear/MatrixWrapper : space/kscience/km
 	public fun get (II)Ljava/lang/Object;
 	public fun get ([I)Ljava/lang/Object;
 	public fun getColNum ()I
-	public fun getColumns ()Lspace/kscience/kmath/structures/Buffer;
+	public fun getColumns ()Ljava/util/List;
 	public fun getDimension ()I
 	public final fun getFeatures ()Ljava/util/Set;
 	public final fun getOrigin ()Lspace/kscience/kmath/nd/Structure2D;
 	public fun getRowNum ()I
-	public fun getRows ()Lspace/kscience/kmath/structures/Buffer;
+	public fun getRows ()Ljava/util/List;
 	public fun getShape ()[I
 	public fun hashCode ()I
 	public fun toString ()Ljava/lang/String;
@@ -622,11 +644,11 @@ public final class space/kscience/kmath/linear/VirtualMatrix : space/kscience/km
 	public fun get (II)Ljava/lang/Object;
 	public fun get ([I)Ljava/lang/Object;
 	public fun getColNum ()I
-	public fun getColumns ()Lspace/kscience/kmath/structures/Buffer;
+	public fun getColumns ()Ljava/util/List;
 	public fun getDimension ()I
 	public final fun getGenerator ()Lkotlin/jvm/functions/Function2;
 	public fun getRowNum ()I
-	public fun getRows ()Lspace/kscience/kmath/structures/Buffer;
+	public fun getRows ()Ljava/util/List;
 	public fun getShape ()[I
 	public fun hashCode ()I
 }
@@ -678,11 +700,11 @@ public final class space/kscience/kmath/nd/BufferNDAlgebra$DefaultImpls {
 
 public final class space/kscience/kmath/nd/BufferNDAlgebraKt {
 	public static final fun field (Lspace/kscience/kmath/nd/NDAlgebra$Companion;Lspace/kscience/kmath/operations/Field;Lkotlin/jvm/functions/Function2;[I)Lspace/kscience/kmath/nd/BufferedNDField;
+	public static final fun group (Lspace/kscience/kmath/nd/NDAlgebra$Companion;Lspace/kscience/kmath/operations/Group;Lkotlin/jvm/functions/Function2;[I)Lspace/kscience/kmath/nd/BufferedNDGroup;
 	public static final fun ndField (Lspace/kscience/kmath/operations/Field;Lkotlin/jvm/functions/Function2;[ILkotlin/jvm/functions/Function1;)Ljava/lang/Object;
+	public static final fun ndGroup (Lspace/kscience/kmath/operations/Group;Lkotlin/jvm/functions/Function2;[ILkotlin/jvm/functions/Function1;)Ljava/lang/Object;
 	public static final fun ndRing (Lspace/kscience/kmath/operations/Ring;Lkotlin/jvm/functions/Function2;[ILkotlin/jvm/functions/Function1;)Ljava/lang/Object;
-	public static final fun ndSpace (Lspace/kscience/kmath/operations/Group;Lkotlin/jvm/functions/Function2;[ILkotlin/jvm/functions/Function1;)Ljava/lang/Object;
 	public static final fun ring (Lspace/kscience/kmath/nd/NDAlgebra$Companion;Lspace/kscience/kmath/operations/Ring;Lkotlin/jvm/functions/Function2;[I)Lspace/kscience/kmath/nd/BufferedNDRing;
-	public static final fun space (Lspace/kscience/kmath/nd/NDAlgebra$Companion;Lspace/kscience/kmath/operations/Group;Lkotlin/jvm/functions/Function2;[I)Lspace/kscience/kmath/nd/BufferedNDGroup;
 }
 
 public class space/kscience/kmath/nd/BufferedNDField : space/kscience/kmath/nd/BufferedNDRing, space/kscience/kmath/nd/NDField {
@@ -1103,9 +1125,9 @@ public abstract interface class space/kscience/kmath/nd/Structure2D : space/ksci
 	public abstract fun get (II)Ljava/lang/Object;
 	public abstract fun get ([I)Ljava/lang/Object;
 	public abstract fun getColNum ()I
-	public abstract fun getColumns ()Lspace/kscience/kmath/structures/Buffer;
+	public abstract fun getColumns ()Ljava/util/List;
 	public abstract fun getRowNum ()I
-	public abstract fun getRows ()Lspace/kscience/kmath/structures/Buffer;
+	public abstract fun getRows ()Ljava/util/List;
 	public abstract fun getShape ()[I
 }
 
@@ -1115,9 +1137,9 @@ public final class space/kscience/kmath/nd/Structure2D$Companion {
 public final class space/kscience/kmath/nd/Structure2D$DefaultImpls {
 	public static fun elements (Lspace/kscience/kmath/nd/Structure2D;)Lkotlin/sequences/Sequence;
 	public static fun get (Lspace/kscience/kmath/nd/Structure2D;[I)Ljava/lang/Object;
-	public static fun getColumns (Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/structures/Buffer;
+	public static fun getColumns (Lspace/kscience/kmath/nd/Structure2D;)Ljava/util/List;
 	public static fun getDimension (Lspace/kscience/kmath/nd/Structure2D;)I
-	public static fun getRows (Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/structures/Buffer;
+	public static fun getRows (Lspace/kscience/kmath/nd/Structure2D;)Ljava/util/List;
 	public static fun getShape (Lspace/kscience/kmath/nd/Structure2D;)[I
 }
 
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpace.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpace.kt
index 4a9d2c9b3..b0331bdea 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpace.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpace.kt
@@ -33,8 +33,7 @@ public interface LinearSpace<T : Any, out A : Ring<T>> {
     /**
      * Produces a point compatible with matrix space (and possibly optimized for it).
      */
-    public fun buildVector(size: Int, initializer: A.(Int) -> T): Vector<T> =
-        buildMatrix(1, size) { _, j -> initializer(j) }.as1D()
+    public fun buildVector(size: Int, initializer: A.(Int) -> T): Vector<T>
 
     public operator fun Matrix<T>.unaryMinus(): Matrix<T> = buildMatrix(rowNum, colNum) { i, j ->
         -get(i, j)
@@ -154,7 +153,7 @@ public interface LinearSpace<T : Any, out A : Ring<T>> {
 
     /**
      * Gets a feature from the matrix. This function may return some additional features to
-     * [space.kscience.kmath.nd.NDStructure.getFeature].
+     * [group.kscience.kmath.nd.NDStructure.getFeature].
      *
      * @param F the type of feature.
      * @param m the matrix.
@@ -172,16 +171,7 @@ public interface LinearSpace<T : Any, out A : Ring<T>> {
         public fun <T : Any, A : Ring<T>> buffered(
             algebra: A,
             bufferFactory: BufferFactory<T> = Buffer.Companion::boxing,
-        ): LinearSpace<T, A> = object : LinearSpace<T, A> {
-            override val elementAlgebra: A = algebra
-
-            override fun buildMatrix(
-                rows: Int, columns: Int,
-                initializer: A.(i: Int, j: Int) -> T,
-            ): Matrix<T> = NDStructure.buffered(intArrayOf(rows, columns), bufferFactory) { (i, j) ->
-                algebra.initializer(i, j)
-            }.as2D()
-        }
+        ): LinearSpace<T, A> = LinearSpaceOverNd(algebra,bufferFactory)
 
         public val real: LinearSpace<Double, RealField> = buffered(RealField, Buffer.Companion::real)
 
@@ -193,9 +183,11 @@ public interface LinearSpace<T : Any, out A : Ring<T>> {
     }
 }
 
+public operator fun <LS : LinearSpace<*, *>, R> LS.invoke(block: LS.() -> R): R = run(block)
+
 /**
  * Gets a feature from the matrix. This function may return some additional features to
- * [space.kscience.kmath.nd.NDStructure.getFeature].
+ * [group.kscience.kmath.nd.NDStructure.getFeature].
  *
  * @param T the type of items in the matrices.
  * @param M the type of operated matrices.
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpaceOverNd.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpaceOverNd.kt
new file mode 100644
index 000000000..6a82f37ec
--- /dev/null
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpaceOverNd.kt
@@ -0,0 +1,85 @@
+package space.kscience.kmath.linear
+
+import space.kscience.kmath.nd.*
+import space.kscience.kmath.operations.Ring
+import space.kscience.kmath.operations.invoke
+import space.kscience.kmath.structures.Buffer
+import space.kscience.kmath.structures.BufferFactory
+import space.kscience.kmath.structures.VirtualBuffer
+import space.kscience.kmath.structures.indices
+
+
+public class LinearSpaceOverNd<T : Any, A : Ring<T>>(
+    override val elementAlgebra: A,
+    private val bufferFactory: BufferFactory<T>,
+) : LinearSpace<T, A> {
+
+    private fun ndRing(
+        rows: Int,
+        cols: Int,
+    ): BufferedNDRing<T, A> = NDAlgebra.ring(elementAlgebra, bufferFactory, rows, cols)
+
+    override fun buildMatrix(rows: Int, columns: Int, initializer: A.(i: Int, j: Int) -> T): Matrix<T> =
+        ndRing(rows, columns).produce { (i, j) -> elementAlgebra.initializer(i, j) }.as2D()
+
+    override fun buildVector(size: Int, initializer: A.(Int) -> T): Vector<T> =
+        bufferFactory(size) { elementAlgebra.initializer(it) }
+
+    override fun Matrix<T>.unaryMinus(): Matrix<T> = ndRing(rowNum, colNum).run {
+        unwrap().map { -it }.as2D()
+    }
+
+    override fun Matrix<T>.plus(other: Matrix<T>): Matrix<T> = ndRing(rowNum, colNum).run {
+        require(shape.contentEquals(other.shape)) { "Shape mismatch on Matrix::plus. Expected $shape but found ${other.shape}" }
+        unwrap().plus(other.unwrap()).as2D()
+    }
+
+    override fun Matrix<T>.minus(other: Matrix<T>): Matrix<T> = ndRing(rowNum, colNum).run {
+        require(shape.contentEquals(other.shape)) { "Shape mismatch on Matrix::plus. Expected $shape but found ${other.shape}" }
+        unwrap().minus(other.unwrap()).as2D()
+    }
+
+    private fun Buffer<T>.linearize() = if (this is VirtualBuffer) {
+        buildVector(size) { get(it) }
+    } else {
+        this
+    }
+
+    override fun Matrix<T>.dot(other: Matrix<T>): Matrix<T> {
+        require(colNum == other.rowNum) { "Matrix dot operation dimension mismatch: ($rowNum, $colNum) x (${other.rowNum}, ${other.colNum})" }
+        return elementAlgebra {
+            val rows = this@dot.rows.map{it.linearize()}
+            val columns = other.columns.map { it.linearize() }
+            //TODO optimize buffers
+            buildMatrix(rowNum, other.colNum) { i, j ->
+                val r = rows[i]
+                val c = columns[j]
+                var res = zero
+                for (l in r.indices) {
+                    res += r[l] * c[l]
+                }
+                res
+            }
+        }
+    }
+
+    override fun Matrix<T>.dot(vector: Vector<T>): Vector<T> {
+        require(colNum == vector.size) { "Matrix dot vector operation dimension mismatch: ($rowNum, $colNum) x (${vector.size})" }
+        return elementAlgebra {
+            val rows = this@dot.rows
+            //TODO optimize buffers
+            buildVector(rowNum) { i ->
+                val r = rows[i]
+                var res = zero
+                for (j in r.indices) {
+                    res += r[j] * vector[j]
+                }
+                res
+            }
+        }
+    }
+
+    override fun Matrix<T>.times(value: T): Matrix<T> = ndRing(rowNum, colNum).run {
+        unwrap().map { it * value }.as2D()
+    }
+}
\ No newline at end of file
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/BufferNDAlgebra.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/BufferNDAlgebra.kt
index 58d1ea7b1..bce3a0830 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/BufferNDAlgebra.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/BufferNDAlgebra.kt
@@ -79,20 +79,20 @@ public open class BufferedNDField<T, R : Field<T>>(
     override fun scale(a: NDStructure<T>, value: Double): NDStructure<T> = a.map { it * value }
 }
 
-// space factories
-public fun <T, A : Group<T>> NDAlgebra.Companion.space(
+// group factories
+public fun <T, A : Group<T>> NDAlgebra.Companion.group(
     space: A,
     bufferFactory: BufferFactory<T>,
     vararg shape: Int,
 ): BufferedNDGroup<T, A> = BufferedNDGroup(shape, space, bufferFactory)
 
-public inline fun <T, A : Group<T>, R> A.ndSpace(
+public inline fun <T, A : Group<T>, R> A.ndGroup(
     noinline bufferFactory: BufferFactory<T>,
     vararg shape: Int,
     action: BufferedNDGroup<T, A>.() -> R,
 ): R {
     contract { callsInPlace(action, InvocationKind.EXACTLY_ONCE) }
-    return NDAlgebra.space(this, bufferFactory, *shape).run(action)
+    return NDAlgebra.group(this, bufferFactory, *shape).run(action)
 }
 
 //ring factories
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/Structure1D.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/Structure1D.kt
index c54bfeed9..1335a4933 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/Structure1D.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/Structure1D.kt
@@ -45,14 +45,12 @@ private inline class Buffer1DWrapper<T>(val buffer: Buffer<T>) : Structure1D<T>
 /**
  * Represent a [NDStructure] as [Structure1D]. Throw error in case of dimension mismatch
  */
-public fun <T> NDStructure<T>.as1D(): Structure1D<T> = if (shape.size == 1) {
+public fun <T> NDStructure<T>.as1D(): Structure1D<T> = this as? Structure1D<T> ?: if (shape.size == 1) {
     when (this) {
-        is Structure1DWrapper -> this
         is NDBuffer -> Buffer1DWrapper(this.buffer)
         else -> Structure1DWrapper(this)
     }
-} else
-    error("Can't create 1d-structure from ${shape.size}d-structure")
+} else error("Can't create 1d-structure from ${shape.size}d-structure")
 
 /**
  * Represent this buffer as 1D structure
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/Structure2D.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/Structure2D.kt
index 09c830646..e9f8234e5 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/Structure2D.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/Structure2D.kt
@@ -26,14 +26,14 @@ public interface Structure2D<T> : NDStructure<T> {
     /**
      * The buffer of rows of this structure. It gets elements from the structure dynamically.
      */
-    public val rows: Buffer<Buffer<T>>
-        get() = VirtualBuffer(rowNum) { i -> VirtualBuffer(colNum) { j -> get(i, j) } }
+    public val rows: List<Buffer<T>>
+        get() = List(rowNum) { i -> VirtualBuffer(colNum) { j -> get(i, j) } }
 
     /**
      * The buffer of columns of this structure. It gets elements from the structure dynamically.
      */
-    public val columns: Buffer<Buffer<T>>
-        get() = VirtualBuffer(colNum) { j -> VirtualBuffer(rowNum) { i -> get(i, j) } }
+    public val columns: List<Buffer<T>>
+        get() = List(colNum) { j -> VirtualBuffer(rowNum) { i -> get(i, j) } }
 
     /**
      * Retrieves an element from the structure by two indices.
@@ -75,20 +75,15 @@ private class Structure2DWrapper<T>(val structure: NDStructure<T>) : Structure2D
 
     override fun equals(other: Any?): Boolean = structure == other
 
-    override fun hashCode(): Int  = structure.hashCode()
+    override fun hashCode(): Int = structure.hashCode()
 }
 
 /**
  * Represent a [NDStructure] as [Structure1D]. Throw error in case of dimension mismatch
  */
-public fun <T> NDStructure<T>.as2D(): Structure2D<T> = if (shape.size == 2)
-    Structure2DWrapper(this)
-else
-    error("Can't create 2d-structure from ${shape.size}d-structure")
+public fun <T> NDStructure<T>.as2D(): Structure2D<T> = this as? Structure2D<T> ?: when (shape.size) {
+    2 -> Structure2DWrapper(this)
+    else -> error("Can't create 2d-structure from ${shape.size}d-structure")
+}
 
-/**
- * Alias for [Structure2D] with more familiar name.
- *
- * @param T the type of items in the matrix.
- */
-public typealias Matrix<T> = Structure2D<T>
+internal fun <T> Structure2D<T>.unwrap(): NDStructure<T> = if (this is Structure2DWrapper) structure else this
\ No newline at end of file
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/BufferAccessor2D.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/BufferAccessor2D.kt
index d9e37ebd8..0910b2034 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/BufferAccessor2D.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/BufferAccessor2D.kt
@@ -13,10 +13,10 @@ internal class BufferAccessor2D<T : Any>(
     public val colNum: Int,
     val factory: MutableBufferFactory<T>,
 ) {
-    public operator fun Buffer<T>.get(i: Int, j: Int): T = get(i + colNum * j)
+    public operator fun Buffer<T>.get(i: Int, j: Int): T = get(i*colNum + j)
 
     public operator fun MutableBuffer<T>.set(i: Int, j: Int, value: T) {
-        set(i + colNum * j, value)
+        set(i*colNum + j, value)
     }
 
     public inline fun create(crossinline init: (i: Int, j: Int) -> T): MutableBuffer<T> =
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/bufferOperation.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/bufferOperation.kt
new file mode 100644
index 000000000..459136631
--- /dev/null
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/bufferOperation.kt
@@ -0,0 +1,7 @@
+package space.kscience.kmath.structures
+
+
+public inline fun <T : Any, reified R : Any> Buffer<T>.map(
+    bufferFactory: BufferFactory<R> = Buffer.Companion::auto,
+    crossinline block: (T) -> R,
+): Buffer<R> = bufferFactory(size) { block(get(it)) }
\ No newline at end of file
diff --git a/kmath-core/src/commonTest/kotlin/space/kscience/kmath/linear/RealLUSolverTest.kt b/kmath-core/src/commonTest/kotlin/space/kscience/kmath/linear/RealLUSolverTest.kt
index 704f91998..fb90b5e11 100644
--- a/kmath-core/src/commonTest/kotlin/space/kscience/kmath/linear/RealLUSolverTest.kt
+++ b/kmath-core/src/commonTest/kotlin/space/kscience/kmath/linear/RealLUSolverTest.kt
@@ -19,13 +19,13 @@ class RealLUSolverTest {
         LinearSpace.real.run {
             val matrix = matrix(2,2)(
                 3.0, 1.0,
-                1.0, 3.0
+                2.0, 3.0
             )
 
             val lup = lup(matrix)
 
             //Check determinant
-            assertEquals(8.0, lup.determinant)
+            assertEquals(7.0, lup.determinant)
 
             assertEquals(lup.p dot matrix, lup.l dot lup.u)
         }
diff --git a/kmath-ejml/src/main/kotlin/space/kscience/kmath/ejml/EjmlLinearSpace.kt b/kmath-ejml/src/main/kotlin/space/kscience/kmath/ejml/EjmlLinearSpace.kt
index 57ce977fd..2d3a928a6 100644
--- a/kmath-ejml/src/main/kotlin/space/kscience/kmath/ejml/EjmlLinearSpace.kt
+++ b/kmath-ejml/src/main/kotlin/space/kscience/kmath/ejml/EjmlLinearSpace.kt
@@ -5,14 +5,13 @@ import space.kscience.kmath.linear.*
 import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.nd.getFeature
 import space.kscience.kmath.operations.RealField
-import space.kscience.kmath.operations.ScaleOperations
 
 /**
  * Represents context of basic operations operating with [EjmlMatrix].
  *
  * @author Iaroslav Postovalov
  */
-public object EjmlLinearSpace : LinearSpace<Double, RealField>, ScaleOperations<Matrix<Double>> {
+public object EjmlLinearSpace : LinearSpace<Double, RealField> {
 
     override val elementAlgebra: RealField get() = RealField
 
@@ -50,7 +49,7 @@ public object EjmlLinearSpace : LinearSpace<Double, RealField>, ScaleOperations<
     private fun SimpleMatrix.wrapMatrix() = EjmlMatrix(this)
     private fun SimpleMatrix.wrapVector() = EjmlVector(this)
 
-    override fun Matrix<Double>.unaryMinus(): Matrix<Double> = this * (-1)
+    override fun Matrix<Double>.unaryMinus(): Matrix<Double> = this * (-1.0)
 
     public override fun Matrix<Double>.dot(other: Matrix<Double>): EjmlMatrix =
         EjmlMatrix(toEjml().origin.mult(other.toEjml().origin))
@@ -61,9 +60,6 @@ public object EjmlLinearSpace : LinearSpace<Double, RealField>, ScaleOperations<
     public override operator fun Matrix<Double>.minus(other: Matrix<Double>): EjmlMatrix =
         (toEjml().origin - other.toEjml().origin).wrapMatrix()
 
-    public override fun scale(a: Matrix<Double>, value: Double): EjmlMatrix =
-        a.toEjml().origin.scale(value).wrapMatrix()
-
     public override operator fun Matrix<Double>.times(value: Double): EjmlMatrix =
         toEjml().origin.scale(value).wrapMatrix()
 
diff --git a/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/dot.kt b/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/dot.kt
index 1a7c1213c..0bc5c111b 100644
--- a/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/dot.kt
+++ b/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/dot.kt
@@ -1,7 +1,7 @@
 package space.kscience.kmath.real
 
 import space.kscience.kmath.linear.LinearSpace
-import space.kscience.kmath.nd.Matrix
+import space.kscience.kmath.linear.Matrix
 
 
 /**
-- 
2.34.1


From 8179be2f6284a01fa5ebfb020ee2051c83265655 Mon Sep 17 00:00:00 2001
From: Alexander Nozik <altavir@gmail.com>
Date: Sun, 14 Mar 2021 09:55:24 +0300
Subject: [PATCH 27/37] cleanup

---
 .../linear/{LinearSpaceOverNd.kt => BufferLinearSpace.kt}   | 6 ++----
 .../kotlin/space/kscience/kmath/linear/LinearSpace.kt       | 2 +-
 2 files changed, 3 insertions(+), 5 deletions(-)
 rename kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/{LinearSpaceOverNd.kt => BufferLinearSpace.kt} (94%)

diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpaceOverNd.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/BufferLinearSpace.kt
similarity index 94%
rename from kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpaceOverNd.kt
rename to kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/BufferLinearSpace.kt
index 6a82f37ec..1ea138063 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpaceOverNd.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/BufferLinearSpace.kt
@@ -9,7 +9,7 @@ import space.kscience.kmath.structures.VirtualBuffer
 import space.kscience.kmath.structures.indices
 
 
-public class LinearSpaceOverNd<T : Any, A : Ring<T>>(
+public class BufferLinearSpace<T : Any, A : Ring<T>>(
     override val elementAlgebra: A,
     private val bufferFactory: BufferFactory<T>,
 ) : LinearSpace<T, A> {
@@ -35,7 +35,7 @@ public class LinearSpaceOverNd<T : Any, A : Ring<T>>(
     }
 
     override fun Matrix<T>.minus(other: Matrix<T>): Matrix<T> = ndRing(rowNum, colNum).run {
-        require(shape.contentEquals(other.shape)) { "Shape mismatch on Matrix::plus. Expected $shape but found ${other.shape}" }
+        require(shape.contentEquals(other.shape)) { "Shape mismatch on Matrix::minus. Expected $shape but found ${other.shape}" }
         unwrap().minus(other.unwrap()).as2D()
     }
 
@@ -50,7 +50,6 @@ public class LinearSpaceOverNd<T : Any, A : Ring<T>>(
         return elementAlgebra {
             val rows = this@dot.rows.map{it.linearize()}
             val columns = other.columns.map { it.linearize() }
-            //TODO optimize buffers
             buildMatrix(rowNum, other.colNum) { i, j ->
                 val r = rows[i]
                 val c = columns[j]
@@ -67,7 +66,6 @@ public class LinearSpaceOverNd<T : Any, A : Ring<T>>(
         require(colNum == vector.size) { "Matrix dot vector operation dimension mismatch: ($rowNum, $colNum) x (${vector.size})" }
         return elementAlgebra {
             val rows = this@dot.rows
-            //TODO optimize buffers
             buildVector(rowNum) { i ->
                 val r = rows[i]
                 var res = zero
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpace.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpace.kt
index b0331bdea..4fd4d28d1 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpace.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpace.kt
@@ -171,7 +171,7 @@ public interface LinearSpace<T : Any, out A : Ring<T>> {
         public fun <T : Any, A : Ring<T>> buffered(
             algebra: A,
             bufferFactory: BufferFactory<T> = Buffer.Companion::boxing,
-        ): LinearSpace<T, A> = LinearSpaceOverNd(algebra,bufferFactory)
+        ): LinearSpace<T, A> = BufferLinearSpace(algebra,bufferFactory)
 
         public val real: LinearSpace<Double, RealField> = buffered(RealField, Buffer.Companion::real)
 
-- 
2.34.1


From 0cc68e72ce58eaca0efe362309ccf0fa72724cf0 Mon Sep 17 00:00:00 2001
From: Alexander Nozik <altavir@gmail.com>
Date: Sun, 14 Mar 2021 09:59:53 +0300
Subject: [PATCH 28/37] cleanup

---
 .../kotlin/space/kscience/kmath/linear/BufferLinearSpace.kt     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/BufferLinearSpace.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/BufferLinearSpace.kt
index 1ea138063..ac6211c4b 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/BufferLinearSpace.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/BufferLinearSpace.kt
@@ -65,7 +65,7 @@ public class BufferLinearSpace<T : Any, A : Ring<T>>(
     override fun Matrix<T>.dot(vector: Vector<T>): Vector<T> {
         require(colNum == vector.size) { "Matrix dot vector operation dimension mismatch: ($rowNum, $colNum) x (${vector.size})" }
         return elementAlgebra {
-            val rows = this@dot.rows
+            val rows = this@dot.rows.map { it.linearize() }
             buildVector(rowNum) { i ->
                 val r = rows[i]
                 var res = zero
-- 
2.34.1


From 5a568c4587ba1b93a1c83d0b5eb2cecd7fe40dbf Mon Sep 17 00:00:00 2001
From: Alexander Nozik <altavir@gmail.com>
Date: Sun, 14 Mar 2021 14:23:53 +0300
Subject: [PATCH 29/37] add gradient example

---
 .../space/kscience/kmath/linear/gradient.kt   | 28 ++++++++++++++
 kmath-core/api/kmath-core.api                 | 38 +++++++++----------
 .../space/kscience/kmath/real/RealVector.kt   | 19 ++++++++--
 3 files changed, 62 insertions(+), 23 deletions(-)
 create mode 100644 examples/src/main/kotlin/space/kscience/kmath/linear/gradient.kt

diff --git a/examples/src/main/kotlin/space/kscience/kmath/linear/gradient.kt b/examples/src/main/kotlin/space/kscience/kmath/linear/gradient.kt
new file mode 100644
index 000000000..ce2b9cb00
--- /dev/null
+++ b/examples/src/main/kotlin/space/kscience/kmath/linear/gradient.kt
@@ -0,0 +1,28 @@
+package space.kscience.kmath.linear
+
+import space.kscience.kmath.real.*
+import space.kscience.kmath.structures.RealBuffer
+
+fun main() {
+    val x0 = Vector(0.0, 0.0, 0.0)
+    val sigma = Vector(1.0, 1.0, 1.0)
+
+    val gaussian: (Vector<Double>) -> Double = { x ->
+        require(x.size == x0.size)
+        kotlin.math.exp(-((x - x0) / sigma).square().sum())
+    }
+
+    fun ((Vector<Double>) -> Double).grad(x: Vector<Double>): Vector<Double> {
+        require(x.size == x0.size)
+        return RealBuffer(x.size) { i ->
+            val h = sigma[i] / 5
+            val dVector = RealBuffer(x.size) { if (it == i) h else 0.0 }
+            val f1 = invoke(x + dVector / 2)
+            val f0 = invoke(x - dVector / 2)
+            (f1 - f0) / h
+        }
+    }
+
+    println(gaussian.grad(x0))
+
+}
\ No newline at end of file
diff --git a/kmath-core/api/kmath-core.api b/kmath-core/api/kmath-core.api
index 38da35d6c..525711e96 100644
--- a/kmath-core/api/kmath-core.api
+++ b/kmath-core/api/kmath-core.api
@@ -432,6 +432,25 @@ public final class space/kscience/kmath/expressions/SymbolIndexerKt {
 	public static final fun withSymbols ([Lspace/kscience/kmath/expressions/Symbol;Lkotlin/jvm/functions/Function1;)Ljava/lang/Object;
 }
 
+public final class space/kscience/kmath/linear/BufferLinearSpace : space/kscience/kmath/linear/LinearSpace {
+	public fun <init> (Lspace/kscience/kmath/operations/Ring;Lkotlin/jvm/functions/Function2;)V
+	public fun buildMatrix (IILkotlin/jvm/functions/Function3;)Lspace/kscience/kmath/nd/Structure2D;
+	public fun buildVector (ILkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/structures/Buffer;
+	public fun dot (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
+	public fun dot (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
+	public fun getElementAlgebra ()Lspace/kscience/kmath/operations/Ring;
+	public fun minus (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
+	public fun minus (Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
+	public fun plus (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
+	public fun plus (Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
+	public fun times (Ljava/lang/Object;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
+	public fun times (Ljava/lang/Object;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
+	public fun times (Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Object;)Lspace/kscience/kmath/nd/Structure2D;
+	public fun times (Lspace/kscience/kmath/structures/Buffer;Ljava/lang/Object;)Lspace/kscience/kmath/structures/Buffer;
+	public fun unaryMinus (Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
+	public fun unaryMinus (Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
+}
+
 public abstract interface class space/kscience/kmath/linear/CholeskyDecompositionFeature : space/kscience/kmath/linear/MatrixFeature {
 	public abstract fun getL ()Lspace/kscience/kmath/nd/Structure2D;
 }
@@ -514,25 +533,6 @@ public final class space/kscience/kmath/linear/LinearSpaceKt {
 	public static final fun invoke (Lspace/kscience/kmath/linear/LinearSpace;Lkotlin/jvm/functions/Function1;)Ljava/lang/Object;
 }
 
-public final class space/kscience/kmath/linear/LinearSpaceOverNd : space/kscience/kmath/linear/LinearSpace {
-	public fun <init> (Lspace/kscience/kmath/operations/Ring;Lkotlin/jvm/functions/Function2;)V
-	public fun buildMatrix (IILkotlin/jvm/functions/Function3;)Lspace/kscience/kmath/nd/Structure2D;
-	public fun buildVector (ILkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/structures/Buffer;
-	public fun dot (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public fun dot (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-	public fun getElementAlgebra ()Lspace/kscience/kmath/operations/Ring;
-	public fun minus (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public fun minus (Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-	public fun plus (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public fun plus (Lspace/kscience/kmath/structures/Buffer;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-	public fun times (Ljava/lang/Object;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public fun times (Ljava/lang/Object;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-	public fun times (Lspace/kscience/kmath/nd/Structure2D;Ljava/lang/Object;)Lspace/kscience/kmath/nd/Structure2D;
-	public fun times (Lspace/kscience/kmath/structures/Buffer;Ljava/lang/Object;)Lspace/kscience/kmath/structures/Buffer;
-	public fun unaryMinus (Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
-	public fun unaryMinus (Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-}
-
 public final class space/kscience/kmath/linear/LupDecomposition : space/kscience/kmath/linear/DeterminantFeature, space/kscience/kmath/linear/LupDecompositionFeature {
 	public fun <init> (Lspace/kscience/kmath/linear/LinearSpace;Lspace/kscience/kmath/operations/Field;Lspace/kscience/kmath/nd/Structure2D;[IZ)V
 	public final fun getContext ()Lspace/kscience/kmath/linear/LinearSpace;
diff --git a/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/RealVector.kt b/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/RealVector.kt
index ca892fa7e..ee42fe404 100644
--- a/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/RealVector.kt
+++ b/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/RealVector.kt
@@ -5,6 +5,7 @@ import space.kscience.kmath.operations.Norm
 import space.kscience.kmath.structures.Buffer
 import space.kscience.kmath.structures.asBuffer
 import space.kscience.kmath.structures.asIterable
+import space.kscience.kmath.structures.indices
 import kotlin.math.pow
 import kotlin.math.sqrt
 
@@ -30,7 +31,7 @@ public inline fun RealVector.mapIndexed(transform: (index: Int, value: Double) -
     Buffer.real(size) { transform(it, get(it)) }
 
 public operator fun RealVector.plus(other: RealVector): RealVector {
-    require(size == other.size){"Vector size $size expected but ${other.size} found"}
+    require(size == other.size) { "Vector size $size expected but ${other.size} found" }
     return mapIndexed { index, value -> value + other[index] }
 }
 
@@ -41,7 +42,7 @@ public operator fun Number.plus(vector: RealVector): RealVector = vector + this
 public operator fun RealVector.unaryMinus(): Buffer<Double> = map { -it }
 
 public operator fun RealVector.minus(other: RealVector): RealVector {
-    require(size == other.size){"Vector size $size expected but ${other.size} found"}
+    require(size == other.size) { "Vector size $size expected but ${other.size} found" }
     return mapIndexed { index, value -> value - other[index] }
 }
 
@@ -50,7 +51,7 @@ public operator fun RealVector.minus(number: Number): RealVector = map { it - nu
 public operator fun Number.minus(vector: RealVector): RealVector = vector.map { toDouble() - it }
 
 public operator fun RealVector.times(other: RealVector): RealVector {
-    require(size == other.size){"Vector size $size expected but ${other.size} found"}
+    require(size == other.size) { "Vector size $size expected but ${other.size} found" }
     return mapIndexed { index, value -> value * other[index] }
 }
 
@@ -59,7 +60,7 @@ public operator fun RealVector.times(number: Number): RealVector = map { it * nu
 public operator fun Number.times(vector: RealVector): RealVector = vector * this
 
 public operator fun RealVector.div(other: RealVector): RealVector {
-    require(size == other.size){"Vector size $size expected but ${other.size} found"}
+    require(size == other.size) { "Vector size $size expected but ${other.size} found" }
     return mapIndexed { index, value -> value / other[index] }
 }
 
@@ -88,3 +89,13 @@ public fun tan(vector: RealVector): RealVector = vector.map { kotlin.math.tan(it
 public fun ln(vector: RealVector): RealVector = vector.map { kotlin.math.ln(it) }
 
 public fun log10(vector: RealVector): RealVector = vector.map { kotlin.math.log10(it) }
+
+// reductions methods
+
+public fun RealVector.sum(): Double {
+    var res = 0.0
+    for (i in indices) {
+        res += get(i)
+    }
+    return res
+}
\ No newline at end of file
-- 
2.34.1


From e01f90b5e03d42a7c0c50591f34222c3607edff5 Mon Sep 17 00:00:00 2001
From: Alexander Nozik <altavir@gmail.com>
Date: Sun, 14 Mar 2021 14:40:13 +0300
Subject: [PATCH 30/37] add gradient example

---
 CHANGELOG.md                                  |  1 +
 .../space/kscience/kmath/linear/gradient.kt   |  8 +-
 .../kscience/kmath/commons/linear/CMMatrix.kt | 16 ++--
 kmath-core/api/kmath-core.api                 | 10 +--
 .../kmath/linear/BufferLinearSpace.kt         |  4 +-
 .../{LinearAlgebra.kt => LinearSolver.kt}     |  5 +-
 .../kscience/kmath/linear/LinearSpace.kt      | 19 ++--
 .../kscience/kmath/linear/MatrixBuilder.kt    |  2 +-
 .../kscience/kmath/linear/RealLinearSpace.kt  | 86 -------------------
 .../kscience/kmath/ejml/EjmlLinearSpace.kt    | 16 ++--
 10 files changed, 41 insertions(+), 126 deletions(-)
 rename kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/{LinearAlgebra.kt => LinearSolver.kt} (83%)
 delete mode 100644 kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/RealLinearSpace.kt

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 05c956de3..47690e36a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,6 +9,7 @@
 - Exponential operations merged with hyperbolic functions
 - Space is replaced by Group. Space is reserved for vector spaces.
 - VectorSpace is now a vector space
+- 
 
 ### Deprecated
 
diff --git a/examples/src/main/kotlin/space/kscience/kmath/linear/gradient.kt b/examples/src/main/kotlin/space/kscience/kmath/linear/gradient.kt
index ce2b9cb00..8dd3d7f6b 100644
--- a/examples/src/main/kotlin/space/kscience/kmath/linear/gradient.kt
+++ b/examples/src/main/kotlin/space/kscience/kmath/linear/gradient.kt
@@ -4,15 +4,15 @@ import space.kscience.kmath.real.*
 import space.kscience.kmath.structures.RealBuffer
 
 fun main() {
-    val x0 = Vector(0.0, 0.0, 0.0)
-    val sigma = Vector(1.0, 1.0, 1.0)
+    val x0 = Point(0.0, 0.0, 0.0)
+    val sigma = Point(1.0, 1.0, 1.0)
 
-    val gaussian: (Vector<Double>) -> Double = { x ->
+    val gaussian: (Point<Double>) -> Double = { x ->
         require(x.size == x0.size)
         kotlin.math.exp(-((x - x0) / sigma).square().sum())
     }
 
-    fun ((Vector<Double>) -> Double).grad(x: Vector<Double>): Vector<Double> {
+    fun ((Point<Double>) -> Double).grad(x: Point<Double>): Point<Double> {
         require(x.size == x0.size)
         return RealBuffer(x.size) { i ->
             val h = sigma[i] / 5
diff --git 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
index b462a1a36..5f632491c 100644
--- 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
@@ -62,7 +62,7 @@ public class CMMatrix(public val origin: RealMatrix) : Matrix<Double> {
     override fun hashCode(): Int = origin.hashCode()
 }
 
-public inline class CMVector(public val origin: RealVector) : Vector<Double> {
+public inline class CMVector(public val origin: RealVector) : Point<Double> {
     public override val size: Int get() = origin.dimension
 
     public override operator fun get(index: Int): Double = origin.getEntry(index)
@@ -94,7 +94,7 @@ public object CMLinearSpace : LinearSpace<Double, RealField> {
         }
     }
 
-    public fun Vector<Double>.toCM(): CMVector = if (this is CMVector) this else {
+    public fun Point<Double>.toCM(): CMVector = if (this is CMVector) this else {
         val array = DoubleArray(size) { this[it] }
         ArrayRealVector(array).wrap()
     }
@@ -102,22 +102,22 @@ public object CMLinearSpace : LinearSpace<Double, RealField> {
     internal fun RealMatrix.wrap(): CMMatrix = CMMatrix(this)
     internal fun RealVector.wrap(): CMVector = CMVector(this)
 
-    override fun buildVector(size: Int, initializer: RealField.(Int) -> Double): Vector<Double> =
+    override fun buildVector(size: Int, initializer: RealField.(Int) -> Double): Point<Double> =
         ArrayRealVector(DoubleArray(size) { RealField.initializer(it) }).wrap()
 
     override fun Matrix<Double>.plus(other: Matrix<Double>): CMMatrix =
         toCM().origin.add(other.toCM().origin).wrap()
 
-    override fun Vector<Double>.plus(other: Vector<Double>): CMVector =
+    override fun Point<Double>.plus(other: Point<Double>): CMVector =
         toCM().origin.add(other.toCM().origin).wrap()
 
-    override fun Vector<Double>.minus(other: Vector<Double>): CMVector =
+    override fun Point<Double>.minus(other: Point<Double>): CMVector =
         toCM().origin.subtract(other.toCM().origin).wrap()
 
     public override fun Matrix<Double>.dot(other: Matrix<Double>): CMMatrix =
         toCM().origin.multiply(other.toCM().origin).wrap()
 
-    public override fun Matrix<Double>.dot(vector: Vector<Double>): CMVector =
+    public override fun Matrix<Double>.dot(vector: Point<Double>): CMVector =
         toCM().origin.preMultiply(vector.toCM().origin).wrap()
 
     public override operator fun Matrix<Double>.minus(other: Matrix<Double>): CMMatrix =
@@ -129,10 +129,10 @@ public object CMLinearSpace : LinearSpace<Double, RealField> {
     override fun Double.times(m: Matrix<Double>): CMMatrix =
         m * this
 
-    override fun Vector<Double>.times(value: Double): CMVector =
+    override fun Point<Double>.times(value: Double): CMVector =
         toCM().origin.mapMultiply(value).wrap()
 
-    override fun Double.times(v: Vector<Double>): CMVector =
+    override fun Double.times(v: Point<Double>): CMVector =
         v * this
 }
 
diff --git a/kmath-core/api/kmath-core.api b/kmath-core/api/kmath-core.api
index 525711e96..b2417fa7d 100644
--- a/kmath-core/api/kmath-core.api
+++ b/kmath-core/api/kmath-core.api
@@ -474,11 +474,6 @@ public final class space/kscience/kmath/linear/LFeature : space/kscience/kmath/l
 	public static final field INSTANCE Lspace/kscience/kmath/linear/LFeature;
 }
 
-public final class space/kscience/kmath/linear/LinearAlgebraKt {
-	public static final fun asMatrix (Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/linear/VirtualMatrix;
-	public static final fun asVector (Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/structures/Buffer;
-}
-
 public abstract interface class space/kscience/kmath/linear/LinearSolver {
 	public abstract fun inverse (Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
 	public abstract fun solve (Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/nd/Structure2D;
@@ -489,6 +484,11 @@ public final class space/kscience/kmath/linear/LinearSolver$DefaultImpls {
 	public static fun solve (Lspace/kscience/kmath/linear/LinearSolver;Lspace/kscience/kmath/nd/Structure2D;Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
 }
 
+public final class space/kscience/kmath/linear/LinearSolverKt {
+	public static final fun asMatrix (Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/linear/VirtualMatrix;
+	public static final fun asVector (Lspace/kscience/kmath/nd/Structure2D;)Lspace/kscience/kmath/structures/Buffer;
+}
+
 public abstract interface class space/kscience/kmath/linear/LinearSpace {
 	public static final field Companion Lspace/kscience/kmath/linear/LinearSpace$Companion;
 	public abstract fun buildMatrix (IILkotlin/jvm/functions/Function3;)Lspace/kscience/kmath/nd/Structure2D;
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/BufferLinearSpace.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/BufferLinearSpace.kt
index ac6211c4b..b6c2ea17b 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/BufferLinearSpace.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/BufferLinearSpace.kt
@@ -22,7 +22,7 @@ public class BufferLinearSpace<T : Any, A : Ring<T>>(
     override fun buildMatrix(rows: Int, columns: Int, initializer: A.(i: Int, j: Int) -> T): Matrix<T> =
         ndRing(rows, columns).produce { (i, j) -> elementAlgebra.initializer(i, j) }.as2D()
 
-    override fun buildVector(size: Int, initializer: A.(Int) -> T): Vector<T> =
+    override fun buildVector(size: Int, initializer: A.(Int) -> T): Point<T> =
         bufferFactory(size) { elementAlgebra.initializer(it) }
 
     override fun Matrix<T>.unaryMinus(): Matrix<T> = ndRing(rowNum, colNum).run {
@@ -62,7 +62,7 @@ public class BufferLinearSpace<T : Any, A : Ring<T>>(
         }
     }
 
-    override fun Matrix<T>.dot(vector: Vector<T>): Vector<T> {
+    override fun Matrix<T>.dot(vector: Point<T>): Point<T> {
         require(colNum == vector.size) { "Matrix dot vector operation dimension mismatch: ($rowNum, $colNum) x (${vector.size})" }
         return elementAlgebra {
             val rows = this@dot.rows.map { it.linearize() }
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearAlgebra.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSolver.kt
similarity index 83%
rename from kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearAlgebra.kt
rename to kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSolver.kt
index 265a709e9..6cce5a446 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearAlgebra.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSolver.kt
@@ -1,9 +1,6 @@
 package space.kscience.kmath.linear
 
 import space.kscience.kmath.nd.as1D
-import space.kscience.kmath.structures.Buffer
-
-public typealias Point<T> = Buffer<T>
 
 /**
  * A group of methods to resolve equation A dot X = B, where A and B are matrices or vectors
@@ -17,7 +14,7 @@ public interface LinearSolver<T : Any> {
 /**
  * Convert matrix to vector if it is possible
  */
-public fun <T : Any> Matrix<T>.asVector(): Vector<T> =
+public fun <T : Any> Matrix<T>.asVector(): Point<T> =
     if (this.colNum == 1)
         as1D()
     else
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpace.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpace.kt
index 4fd4d28d1..de9ac35db 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpace.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpace.kt
@@ -14,7 +14,10 @@ import kotlin.reflect.KClass
  */
 public typealias Matrix<T> = Structure2D<T>
 
-public typealias Vector<T> = Point<T>
+/**
+ * Alias or using [Buffer] as a point/vector in a many-dimensional space.
+ */
+public typealias Point<T> = Buffer<T>
 
 /**
  * Basic operations on matrices and vectors. Operates on [Matrix].
@@ -33,13 +36,13 @@ public interface LinearSpace<T : Any, out A : Ring<T>> {
     /**
      * Produces a point compatible with matrix space (and possibly optimized for it).
      */
-    public fun buildVector(size: Int, initializer: A.(Int) -> T): Vector<T>
+    public fun buildVector(size: Int, initializer: A.(Int) -> T): Point<T>
 
     public operator fun Matrix<T>.unaryMinus(): Matrix<T> = buildMatrix(rowNum, colNum) { i, j ->
         -get(i, j)
     }
 
-    public operator fun Vector<T>.unaryMinus(): Vector<T> = buildVector(size) {
+    public operator fun Point<T>.unaryMinus(): Point<T> = buildVector(size) {
         -get(it)
     }
 
@@ -54,7 +57,7 @@ public interface LinearSpace<T : Any, out A : Ring<T>> {
     /**
      * Vector sum
      */
-    public operator fun Vector<T>.plus(other: Vector<T>): Vector<T> = buildVector(size) {
+    public operator fun Point<T>.plus(other: Point<T>): Point<T> = buildVector(size) {
         get(it) + other[it]
     }
 
@@ -68,7 +71,7 @@ public interface LinearSpace<T : Any, out A : Ring<T>> {
     /**
      * Vector subtraction
      */
-    public operator fun Vector<T>.minus(other: Vector<T>): Vector<T> = buildVector(size) {
+    public operator fun Point<T>.minus(other: Point<T>): Point<T> = buildVector(size) {
         get(it) - other[it]
     }
 
@@ -100,7 +103,7 @@ public interface LinearSpace<T : Any, out A : Ring<T>> {
      * @param vector the multiplier.
      * @return the dot product.
      */
-    public infix fun Matrix<T>.dot(vector: Vector<T>): Vector<T> {
+    public infix fun Matrix<T>.dot(vector: Point<T>): Point<T> {
         require(colNum == vector.size) { "Matrix dot vector operation dimension mismatch: ($rowNum, $colNum) x (${vector.size})" }
         return elementAlgebra {
             buildVector(rowNum) { i ->
@@ -139,7 +142,7 @@ public interface LinearSpace<T : Any, out A : Ring<T>> {
      * @param value the multiplier.
      * @receiver the product.
      */
-    public operator fun Vector<T>.times(value: T): Vector<T> =
+    public operator fun Point<T>.times(value: T): Point<T> =
         buildVector(size) { i -> get(i) * value }
 
     /**
@@ -149,7 +152,7 @@ public interface LinearSpace<T : Any, out A : Ring<T>> {
      * @param v the multiplier.
      * @receiver the product.
      */
-    public operator fun T.times(v: Vector<T>): Vector<T> = v * this
+    public operator fun T.times(v: Point<T>): Point<T> = v * this
 
     /**
      * Gets a feature from the matrix. This function may return some additional features to
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixBuilder.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixBuilder.kt
index 0a7f280bc..b30d621fe 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixBuilder.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixBuilder.kt
@@ -24,7 +24,7 @@ public fun <T : Any, A : Ring<T>> LinearSpace<T, A>.matrix(rows: Int, columns: I
     MatrixBuilder(this, rows, columns)
 
 @UnstableKMathAPI
-public fun <T : Any> LinearSpace<T, Ring<T>>.vector(vararg elements: T): Vector<T> {
+public fun <T : Any> LinearSpace<T, Ring<T>>.vector(vararg elements: T): Point<T> {
     return buildVector(elements.size) { elements[it] }
 }
 
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/RealLinearSpace.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/RealLinearSpace.kt
deleted file mode 100644
index 3fa23db82..000000000
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/RealLinearSpace.kt
+++ /dev/null
@@ -1,86 +0,0 @@
-package space.kscience.kmath.linear
-
-//public object RealLinearSpace:
-
-//public object RealLinearSpace : LinearSpace<Double, RealField>, ScaleOperations<Matrix<Double>> {
-//
-//    override val elementAlgebra: RealField get() = RealField
-//
-//    public override fun buildMatrix(
-//        rows: Int,
-//        columns: Int,
-//        initializer: (i: Int, j: Int) -> Double,
-//    ): Matrix<Double> {
-//        val buffer = RealBuffer(rows * columns) { offset -> initializer(offset / columns, offset % columns) }
-//        return  BufferMatrix(rows, columns, buffer)
-//    }
-//
-//    public fun Matrix<Double>.toBufferMatrix(): BufferMatrix<Double> = if (this is BufferMatrix) this else {
-//        buildMatrix(rowNum, colNum) { i, j -> get(i, j) }
-//    }
-//
-//    public fun one(rows: Int, columns: Int): Matrix<Double> = VirtualMatrix(rows, columns) { i, j ->
-//        if (i == j) 1.0 else 0.0
-//    } + DiagonalFeature
-//
-//    override fun Matrix<Double>.unaryMinus(): Matrix<Double> = buildMatrix(rowNum, colNum) { i, j -> -get(i, j) }
-//
-//    public override infix fun Matrix<Double>.dot(other: Matrix<Double>): BufferMatrix<Double> {
-//        require(colNum == other.rowNum) { "Matrix dot operation dimension mismatch: ($rowNum, $colNum) x (${other.rowNum}, ${other.colNum})" }
-//        val bufferMatrix = toBufferMatrix()
-//        val otherBufferMatrix = other.toBufferMatrix()
-//        return buildMatrix(rowNum, other.colNum) { i, j ->
-//            var res = 0.0
-//            for (l in 0 until colNum) {
-//                res += bufferMatrix[i, l] * otherBufferMatrix[l, j]
-//            }
-//            res
-//        }
-//    }
-//
-//    public override infix fun Matrix<Double>.dot(vector: Point<Double>): Point<Double> {
-//        require(colNum == vector.size) { "Matrix dot vector operation dimension mismatch: ($rowNum, $colNum) x (${vector.size})" }
-//        val bufferMatrix = toBufferMatrix()
-//        return RealBuffer(rowNum) { i ->
-//            var res = 0.0
-//            for (j in 0 until colNum) {
-//                res += bufferMatrix[i, j] * vector[j]
-//            }
-//            res
-//        }
-//    }
-//
-//    override fun add(a: Matrix<Double>, b: Matrix<Double>): BufferMatrix<Double> {
-//        require(a.rowNum == b.rowNum) { "Row number mismatch in matrix addition. Left side: ${a.rowNum}, right side: ${b.rowNum}" }
-//        require(a.colNum == b.colNum) { "Column number mismatch in matrix addition. Left side: ${a.colNum}, right side: ${b.colNum}" }
-//        val aBufferMatrix = a.toBufferMatrix()
-//        val bBufferMatrix = b.toBufferMatrix()
-//        return buildMatrix(a.rowNum, a.colNum) { i, j ->
-//            aBufferMatrix[i, j] + bBufferMatrix[i, j]
-//        }
-//    }
-//
-//    override fun scale(a: Matrix<Double>, value: Double): BufferMatrix<Double> {
-//        val bufferMatrix = a.toBufferMatrix()
-//        return buildMatrix(a.rowNum, a.colNum) { i, j -> bufferMatrix[i, j] * value }
-//    }
-//
-//    override fun Matrix<Double>.times(value: Double): BufferMatrix<Double> = scale(this, value)
-//
-////
-////    override fun multiply(a: Matrix<Double>, k: Number): BufferMatrix<Double> {
-////        val aBufferMatrix = a.toBufferMatrix()
-////        return produce(a.rowNum, a.colNum) { i, j -> aBufferMatrix[i, j] * k.toDouble() }
-////    }
-////
-////    override fun divide(a: Matrix<Double>, k: Number): BufferMatrix<Double> {
-////        val aBufferMatrix = a.toBufferMatrix()
-////        return produce(a.rowNum, a.colNum) { i, j -> aBufferMatrix[i, j] / k.toDouble() }
-////    }
-//}
-
-
-///**
-// * Partially optimized real-valued matrix
-// */
-//public val LinearSpace.Companion.real: RealLinearSpace get() = RealLinearSpace
diff --git a/kmath-ejml/src/main/kotlin/space/kscience/kmath/ejml/EjmlLinearSpace.kt b/kmath-ejml/src/main/kotlin/space/kscience/kmath/ejml/EjmlLinearSpace.kt
index 2d3a928a6..eecd88681 100644
--- a/kmath-ejml/src/main/kotlin/space/kscience/kmath/ejml/EjmlLinearSpace.kt
+++ b/kmath-ejml/src/main/kotlin/space/kscience/kmath/ejml/EjmlLinearSpace.kt
@@ -27,7 +27,7 @@ public object EjmlLinearSpace : LinearSpace<Double, RealField> {
     /**
      * Converts this vector to EJML one.
      */
-    public fun Vector<Double>.toEjml(): EjmlVector = when (this) {
+    public fun Point<Double>.toEjml(): EjmlVector = when (this) {
         is EjmlVector -> this
         else -> EjmlVector(SimpleMatrix(size, 1).also {
             (0 until it.numRows()).forEach { row -> it[row, 0] = get(row) }
@@ -41,7 +41,7 @@ public object EjmlLinearSpace : LinearSpace<Double, RealField> {
             }
         })
 
-    override fun buildVector(size: Int, initializer: RealField.(Int) -> Double): Vector<Double> =
+    override fun buildVector(size: Int, initializer: RealField.(Int) -> Double): Point<Double> =
         EjmlVector(SimpleMatrix(size, 1).also {
             (0 until it.numRows()).forEach { row -> it[row, 0] = RealField.initializer(row) }
         })
@@ -54,7 +54,7 @@ public object EjmlLinearSpace : LinearSpace<Double, RealField> {
     public override fun Matrix<Double>.dot(other: Matrix<Double>): EjmlMatrix =
         EjmlMatrix(toEjml().origin.mult(other.toEjml().origin))
 
-    public override fun Matrix<Double>.dot(vector: Vector<Double>): EjmlVector =
+    public override fun Matrix<Double>.dot(vector: Point<Double>): EjmlVector =
         EjmlVector(toEjml().origin.mult(vector.toEjml().origin))
 
     public override operator fun Matrix<Double>.minus(other: Matrix<Double>): EjmlMatrix =
@@ -63,25 +63,25 @@ public object EjmlLinearSpace : LinearSpace<Double, RealField> {
     public override operator fun Matrix<Double>.times(value: Double): EjmlMatrix =
         toEjml().origin.scale(value).wrapMatrix()
 
-    override fun Vector<Double>.unaryMinus(): EjmlVector =
+    override fun Point<Double>.unaryMinus(): EjmlVector =
         toEjml().origin.negative().wrapVector()
 
     override fun Matrix<Double>.plus(other: Matrix<Double>): EjmlMatrix =
         (toEjml().origin + other.toEjml().origin).wrapMatrix()
 
-    override fun Vector<Double>.plus(other: Vector<Double>): EjmlVector =
+    override fun Point<Double>.plus(other: Point<Double>): EjmlVector =
         (toEjml().origin + other.toEjml().origin).wrapVector()
 
-    override fun Vector<Double>.minus(other: Vector<Double>): EjmlVector =
+    override fun Point<Double>.minus(other: Point<Double>): EjmlVector =
         (toEjml().origin - other.toEjml().origin).wrapVector()
 
     override fun Double.times(m: Matrix<Double>): EjmlMatrix =
         m.toEjml().origin.scale(this).wrapMatrix()
 
-    override fun Vector<Double>.times(value: Double): EjmlVector =
+    override fun Point<Double>.times(value: Double): EjmlVector =
         toEjml().origin.scale(value).wrapVector()
 
-    override fun Double.times(v: Vector<Double>): EjmlVector =
+    override fun Double.times(v: Point<Double>): EjmlVector =
         v.toEjml().origin.scale(this).wrapVector()
 }
 
-- 
2.34.1


From 6c451b5ca7d5891e1553d5023dd4e42c662db234 Mon Sep 17 00:00:00 2001
From: Alexander Nozik <altavir@gmail.com>
Date: Sun, 14 Mar 2021 15:09:04 +0300
Subject: [PATCH 31/37] fix doc typo

---
 .../kotlin/space/kscience/kmath/linear/LinearSpace.kt         | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpace.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpace.kt
index de9ac35db..1642bfb14 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpace.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpace.kt
@@ -156,7 +156,7 @@ public interface LinearSpace<T : Any, out A : Ring<T>> {
 
     /**
      * Gets a feature from the matrix. This function may return some additional features to
-     * [group.kscience.kmath.nd.NDStructure.getFeature].
+     * [space.kscience.kmath.nd.NDStructure.getFeature].
      *
      * @param F the type of feature.
      * @param m the matrix.
@@ -190,7 +190,7 @@ public operator fun <LS : LinearSpace<*, *>, R> LS.invoke(block: LS.() -> R): R
 
 /**
  * Gets a feature from the matrix. This function may return some additional features to
- * [group.kscience.kmath.nd.NDStructure.getFeature].
+ * [space.kscience.kmath.nd.NDStructure.getFeature].
  *
  * @param T the type of items in the matrices.
  * @param M the type of operated matrices.
-- 
2.34.1


From 0e0deaeb72d0ecc4cb6acb7fa6a1409b249f555b Mon Sep 17 00:00:00 2001
From: Alexander Nozik <altavir@gmail.com>
Date: Mon, 15 Mar 2021 14:26:17 +0300
Subject: [PATCH 32/37] Refactor buffer factories

---
 CHANGELOG.md                                  |   2 +-
 kmath-core/api/kmath-core.api                 |  17 +-
 ...rLinearSpace.kt => BufferedLinearSpace.kt} |   2 +-
 .../kscience/kmath/linear/LinearSolver.kt     |  13 +-
 .../kscience/kmath/linear/LinearSpace.kt      |   5 +-
 .../kscience/kmath/linear/LupDecomposition.kt |   6 +-
 .../space/kscience/kmath/nd/NDStructure.kt    |   4 +-
 .../space/kscience/kmath/nd/RealNDField.kt    |   3 +-
 .../space/kscience/kmath/nd/Structure1D.kt    |   9 ++
 .../space/kscience/kmath/nd/Structure2D.kt    |   7 +-
 .../space/kscience/kmath/structures/Buffer.kt | 150 +++++++-----------
 .../kmath/structures/bufferOperation.kt       |  79 ++++++++-
 .../space/kscience/kmath/real/RealVector.kt   |   7 +-
 .../kaceince/kmath/real/RealVectorTest.kt     |  12 +-
 .../kscience/kmath/histogram/Histogram.kt     |   4 +-
 .../space/kscience/kmath/stat/Distribution.kt |   3 +-
 16 files changed, 198 insertions(+), 125 deletions(-)
 rename kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/{BufferLinearSpace.kt => BufferedLinearSpace.kt} (98%)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 47690e36a..eb97698c6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,7 +9,7 @@
 - Exponential operations merged with hyperbolic functions
 - Space is replaced by Group. Space is reserved for vector spaces.
 - VectorSpace is now a vector space
-- 
+- Buffer factories for primitives moved to MutableBuffer.Companion
 
 ### Deprecated
 
diff --git a/kmath-core/api/kmath-core.api b/kmath-core/api/kmath-core.api
index 2fa9e165b..c5e13fe20 100644
--- a/kmath-core/api/kmath-core.api
+++ b/kmath-core/api/kmath-core.api
@@ -432,7 +432,7 @@ public final class space/kscience/kmath/expressions/SymbolIndexerKt {
 	public static final fun withSymbols ([Lspace/kscience/kmath/expressions/Symbol;Lkotlin/jvm/functions/Function1;)Ljava/lang/Object;
 }
 
-public final class space/kscience/kmath/linear/BufferLinearSpace : space/kscience/kmath/linear/LinearSpace {
+public final class space/kscience/kmath/linear/BufferedLinearSpace : space/kscience/kmath/linear/LinearSpace {
 	public fun <init> (Lspace/kscience/kmath/operations/Ring;Lkotlin/jvm/functions/Function2;)V
 	public fun buildMatrix (IILkotlin/jvm/functions/Function3;)Lspace/kscience/kmath/nd/Structure2D;
 	public fun buildVector (ILkotlin/jvm/functions/Function2;)Lspace/kscience/kmath/structures/Buffer;
@@ -2115,7 +2115,6 @@ public abstract interface class space/kscience/kmath/structures/Buffer {
 public final class space/kscience/kmath/structures/Buffer$Companion {
 	public final fun auto (Lkotlin/reflect/KClass;ILkotlin/jvm/functions/Function1;)Lspace/kscience/kmath/structures/Buffer;
 	public final fun boxing (ILkotlin/jvm/functions/Function1;)Lspace/kscience/kmath/structures/Buffer;
-	public final fun real-8hrHhI4 (ILkotlin/jvm/functions/Function1;)[D
 }
 
 public final class space/kscience/kmath/structures/Buffer$DefaultImpls {
@@ -2123,15 +2122,17 @@ public final class space/kscience/kmath/structures/Buffer$DefaultImpls {
 }
 
 public final class space/kscience/kmath/structures/BufferKt {
-	public static final fun ListBuffer (ILkotlin/jvm/functions/Function1;)Ljava/util/List;
 	public static final fun asBuffer (Ljava/util/List;)Ljava/util/List;
 	public static final fun asBuffer ([Ljava/lang/Object;)Lspace/kscience/kmath/structures/ArrayBuffer;
-	public static final fun asIterable (Lspace/kscience/kmath/structures/Buffer;)Ljava/lang/Iterable;
+	public static final fun asMutableBuffer (Ljava/util/List;)Ljava/util/List;
 	public static final fun asReadOnly (Lspace/kscience/kmath/structures/Buffer;)Lspace/kscience/kmath/structures/Buffer;
-	public static final fun asSequence (Lspace/kscience/kmath/structures/Buffer;)Lkotlin/sequences/Sequence;
 	public static final fun getIndices (Lspace/kscience/kmath/structures/Buffer;)Lkotlin/ranges/IntRange;
+}
+
+public final class space/kscience/kmath/structures/BufferOperationKt {
+	public static final fun asIterable (Lspace/kscience/kmath/structures/Buffer;)Ljava/lang/Iterable;
+	public static final fun asSequence (Lspace/kscience/kmath/structures/Buffer;)Lkotlin/sequences/Sequence;
 	public static final fun toList (Lspace/kscience/kmath/structures/Buffer;)Ljava/util/List;
-	public static final fun toMutableList (Lspace/kscience/kmath/structures/Buffer;)Ljava/util/List;
 }
 
 public abstract interface class space/kscience/kmath/structures/FlaggedBuffer : space/kscience/kmath/structures/Buffer {
@@ -2316,7 +2317,11 @@ public abstract interface class space/kscience/kmath/structures/MutableBuffer :
 public final class space/kscience/kmath/structures/MutableBuffer$Companion {
 	public final fun auto (Lkotlin/reflect/KClass;ILkotlin/jvm/functions/Function1;)Lspace/kscience/kmath/structures/MutableBuffer;
 	public final fun boxing (ILkotlin/jvm/functions/Function1;)Lspace/kscience/kmath/structures/MutableBuffer;
+	public final fun float-YxruXGw (ILkotlin/jvm/functions/Function1;)[F
+	public final fun int-Ye6GY2U (ILkotlin/jvm/functions/Function1;)[I
+	public final fun long-BuQOeTY (ILkotlin/jvm/functions/Function1;)[J
 	public final fun real-8hrHhI4 (ILkotlin/jvm/functions/Function1;)[D
+	public final fun short-1yRgbGw (ILkotlin/jvm/functions/Function1;)[S
 }
 
 public final class space/kscience/kmath/structures/MutableBuffer$DefaultImpls {
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/BufferLinearSpace.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/BufferedLinearSpace.kt
similarity index 98%
rename from kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/BufferLinearSpace.kt
rename to kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/BufferedLinearSpace.kt
index b6c2ea17b..5814ab35c 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/BufferLinearSpace.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/BufferedLinearSpace.kt
@@ -9,7 +9,7 @@ import space.kscience.kmath.structures.VirtualBuffer
 import space.kscience.kmath.structures.indices
 
 
-public class BufferLinearSpace<T : Any, A : Ring<T>>(
+public class BufferedLinearSpace<T : Any, A : Ring<T>>(
     override val elementAlgebra: A,
     private val bufferFactory: BufferFactory<T>,
 ) : LinearSpace<T, A> {
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSolver.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSolver.kt
index 6cce5a446..af136c552 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSolver.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSolver.kt
@@ -6,9 +6,20 @@ import space.kscience.kmath.nd.as1D
  * A group of methods to resolve equation A dot X = B, where A and B are matrices or vectors
  */
 public interface LinearSolver<T : Any> {
+    /**
+     * Solve a dot x = b matrix equation and return x
+     */
     public fun solve(a: Matrix<T>, b: Matrix<T>): Matrix<T>
+
+    /**
+     * Solve a dot x = b vector equation and return b
+     */
     public fun solve(a: Matrix<T>, b: Point<T>): Point<T> = solve(a, b.asMatrix()).asVector()
-    public fun inverse(a: Matrix<T>): Matrix<T>
+
+    /**
+     * Get inverse of a matrix
+     */
+    public fun inverse(matrix: Matrix<T>): Matrix<T>
 }
 
 /**
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpace.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpace.kt
index 1642bfb14..cf8564e08 100644
--- 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,6 +5,7 @@ import space.kscience.kmath.nd.*
 import space.kscience.kmath.operations.*
 import space.kscience.kmath.structures.Buffer
 import space.kscience.kmath.structures.BufferFactory
+import space.kscience.kmath.structures.RealBuffer
 import kotlin.reflect.KClass
 
 /**
@@ -174,9 +175,9 @@ public interface LinearSpace<T : Any, out A : Ring<T>> {
         public fun <T : Any, A : Ring<T>> buffered(
             algebra: A,
             bufferFactory: BufferFactory<T> = Buffer.Companion::boxing,
-        ): LinearSpace<T, A> = BufferLinearSpace(algebra,bufferFactory)
+        ): LinearSpace<T, A> = BufferedLinearSpace(algebra,bufferFactory)
 
-        public val real: LinearSpace<Double, RealField> = buffered(RealField, Buffer.Companion::real)
+        public val real: LinearSpace<Double, RealField> = buffered(RealField, ::RealBuffer)
 
         /**
          * Automatic buffered matrix, unboxed if it is possible
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LupDecomposition.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LupDecomposition.kt
index 0937f1e19..eed50ec28 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LupDecomposition.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LupDecomposition.kt
@@ -3,10 +3,10 @@ package space.kscience.kmath.linear
 import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.nd.getFeature
 import space.kscience.kmath.operations.*
-import space.kscience.kmath.structures.Buffer
 import space.kscience.kmath.structures.BufferAccessor2D
 import space.kscience.kmath.structures.MutableBuffer
 import space.kscience.kmath.structures.MutableBufferFactory
+import space.kscience.kmath.structures.RealBuffer
 
 /**
  * Common implementation of [LupDecompositionFeature].
@@ -152,7 +152,7 @@ public inline fun <reified T : Comparable<T>> LinearSpace<T, Field<T>>.lup(
 ): LupDecomposition<T> = lup(MutableBuffer.Companion::auto, matrix, checkSingular)
 
 public fun LinearSpace<Double, RealField>.lup(matrix: Matrix<Double>): LupDecomposition<Double> =
-    lup(Buffer.Companion::real, matrix) { it < 1e-11 }
+    lup(::RealBuffer, matrix) { it < 1e-11 }
 
 public fun <T : Any> LupDecomposition<T>.solveWithLup(
     factory: MutableBufferFactory<T>,
@@ -230,7 +230,7 @@ public inline fun <reified T : Comparable<T>> LinearSpace<T, Field<T>>.inverseWi
 @OptIn(UnstableKMathAPI::class)
 public fun LinearSpace<Double, RealField>.solveWithLup(a: Matrix<Double>, b: Matrix<Double>): Matrix<Double> {
     // Use existing decomposition if it is provided by matrix
-    val bufferFactory: MutableBufferFactory<Double> = MutableBuffer.Companion::real
+    val bufferFactory: MutableBufferFactory<Double> = ::RealBuffer
     val decomposition: LupDecomposition<Double> = a.getFeature() ?: lup(bufferFactory, a) { it < 1e-11 }
     return decomposition.solveWithLup(bufferFactory, b)
 }
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/NDStructure.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/NDStructure.kt
index 48041df58..d758f195d 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/NDStructure.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/NDStructure.kt
@@ -48,8 +48,8 @@ public interface NDStructure<T> {
     public override fun hashCode(): Int
 
     /**
-     * Feature is additional property or hint that does not directly affect the structure, but could in some cases help
-     * optimize operations and performance. If the feature is not present, null is defined.
+     * Feature is some additional strucure information which allows to access it special properties or hints.
+     * If the feature is not present, null is returned.
      */
     @UnstableKMathAPI
     public fun <F : Any> getFeature(type: KClass<F>): F? = null
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/RealNDField.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/RealNDField.kt
index 2165aea22..9f1f14af1 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/RealNDField.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/RealNDField.kt
@@ -5,7 +5,6 @@ import space.kscience.kmath.operations.ExtendedField
 import space.kscience.kmath.operations.NumbersAddOperations
 import space.kscience.kmath.operations.RealField
 import space.kscience.kmath.operations.ScaleOperations
-import space.kscience.kmath.structures.Buffer
 import space.kscience.kmath.structures.RealBuffer
 import kotlin.contracts.InvocationKind
 import kotlin.contracts.contract
@@ -13,7 +12,7 @@ import kotlin.contracts.contract
 @OptIn(UnstableKMathAPI::class)
 public class RealNDField(
     shape: IntArray,
-) : BufferedNDField<Double, RealField>(shape, RealField, Buffer.Companion::real),
+) : BufferedNDField<Double, RealField>(shape, RealField, ::RealBuffer),
     NumbersAddOperations<NDStructure<Double>>,
     ScaleOperations<NDStructure<Double>>,
     ExtendedField<NDStructure<Double>> {
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/Structure1D.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/Structure1D.kt
index 1335a4933..ac8714803 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/Structure1D.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/Structure1D.kt
@@ -56,3 +56,12 @@ public fun <T> NDStructure<T>.as1D(): Structure1D<T> = this as? Structure1D<T> ?
  * Represent this buffer as 1D structure
  */
 public fun <T> Buffer<T>.asND(): Structure1D<T> = Buffer1DWrapper(this)
+
+/**
+ * Expose inner buffer of this [Structure1D] if possible
+ */
+internal fun <T : Any> Structure1D<T>.unwrap(): Buffer<T> = when {
+    this is Buffer1DWrapper<T> -> buffer
+    this is Structure1DWrapper && structure is NDBuffer<T> -> structure.buffer
+    else -> this
+}
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/Structure2D.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/Structure2D.kt
index e9f8234e5..60dedc933 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/Structure2D.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/Structure2D.kt
@@ -86,4 +86,9 @@ public fun <T> NDStructure<T>.as2D(): Structure2D<T> = this as? Structure2D<T> ?
     else -> error("Can't create 2d-structure from ${shape.size}d-structure")
 }
 
-internal fun <T> Structure2D<T>.unwrap(): NDStructure<T> = if (this is Structure2DWrapper) structure else this
\ No newline at end of file
+/**
+ * Expose inner [NDStructure] if possible
+ */
+internal fun <T> Structure2D<T>.unwrap(): NDStructure<T> =
+    if (this is Structure2DWrapper) structure
+    else this
\ No newline at end of file
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/Buffer.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/Buffer.kt
index 2bde18fce..1d40a2f2e 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/Buffer.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/Buffer.kt
@@ -44,21 +44,12 @@ public interface Buffer<out T> {
         asSequence().mapIndexed { index, value -> value == other[index] }.all { it }
 
     public companion object {
-        /**
-         * Creates a [RealBuffer] with the specified [size], where each element is calculated by calling the specified
-         * [initializer] function.
-         */
-        public inline fun real(size: Int, initializer: (Int) -> Double): RealBuffer =
-            RealBuffer(size) { initializer(it) }
-
         /**
          * Creates a [ListBuffer] of given type [T] with given [size]. Each element is calculated by calling the
          * specified [initializer] function.
          */
         public inline fun <T> boxing(size: Int, initializer: (Int) -> T): Buffer<T> =
-            ListBuffer(List(size, initializer))
-
-        // TODO add resolution based on Annotation or companion resolution
+            List(size, initializer).asBuffer()
 
         /**
          * Creates a [Buffer] of given [type]. If the type is primitive, specialized buffers are used ([IntBuffer],
@@ -69,11 +60,11 @@ public interface Buffer<out T> {
         @Suppress("UNCHECKED_CAST")
         public inline fun <T : Any> auto(type: KClass<T>, size: Int, initializer: (Int) -> T): Buffer<T> =
             when (type) {
-                Double::class -> RealBuffer(size) { initializer(it) as Double } as Buffer<T>
-                Short::class -> ShortBuffer(size) { initializer(it) as Short } as Buffer<T>
-                Int::class -> IntBuffer(size) { initializer(it) as Int } as Buffer<T>
-                Long::class -> LongBuffer(size) { initializer(it) as Long } as Buffer<T>
-                Float::class -> FloatBuffer(size) { initializer(it) as Float } as Buffer<T>
+                Double::class -> MutableBuffer.real(size) { initializer(it) as Double } as Buffer<T>
+                Short::class -> MutableBuffer.short(size) { initializer(it) as Short } as Buffer<T>
+                Int::class -> MutableBuffer.int(size) { initializer(it) as Int } as Buffer<T>
+                Long::class -> MutableBuffer.long(size) { initializer(it) as Long } as Buffer<T>
+                Float::class -> MutableBuffer.float(size) { initializer(it) as Float } as Buffer<T>
                 else -> boxing(size, initializer)
             }
 
@@ -89,41 +80,6 @@ public interface Buffer<out T> {
     }
 }
 
-/**
- * Creates a sequence that returns all elements from this [Buffer].
- */
-public fun <T> Buffer<T>.asSequence(): Sequence<T> = Sequence(::iterator)
-
-/**
- * Creates an iterable that returns all elements from this [Buffer].
- */
-public fun <T> Buffer<T>.asIterable(): Iterable<T> = Iterable(::iterator)
-
-/**
- * Returns a new [List] containing all elements of this buffer.
- */
-public fun <T> Buffer<T>.toList(): List<T> = when (this) {
-    is ArrayBuffer<T> -> array.toList()
-    is ListBuffer<T> -> list.toList()
-    is MutableListBuffer<T> -> list.toList()
-    else -> asSequence().toList()
-}
-
-/**
- * Returns a new [MutableList] filled with all elements of this buffer.
- */
-public fun <T> Buffer<T>.toMutableList(): MutableList<T> = when (this) {
-    is ArrayBuffer<T> -> array.toMutableList()
-    is ListBuffer<T> -> list.toMutableList()
-    is MutableListBuffer<T> -> list.toMutableList()
-    else -> asSequence().toMutableList()
-}
-
-/**
- * Returns a new [Array] containing all elements of this buffer.
- */
-public inline fun <reified T> Buffer<T>.toTypedArray(): Array<T> = asSequence().toList().toTypedArray()
-
 /**
  * Returns an [IntRange] of the valid indices for this [Buffer].
  */
@@ -146,6 +102,44 @@ public interface MutableBuffer<T> : Buffer<T> {
     public fun copy(): MutableBuffer<T>
 
     public companion object {
+
+        /**
+         * Creates a [RealBuffer] with the specified [size], where each element is calculated by calling the specified
+         * [initializer] function.
+         */
+        public inline fun real(size: Int, initializer: (Int) -> Double): RealBuffer =
+            RealBuffer(size, initializer)
+
+        /**
+         * Creates a [ShortBuffer] with the specified [size], where each element is calculated by calling the specified
+         * [initializer] function.
+         */
+        public inline fun short(size: Int, initializer: (Int) -> Short): ShortBuffer =
+            ShortBuffer(size, initializer)
+
+        /**
+         * Creates a [IntBuffer] with the specified [size], where each element is calculated by calling the specified
+         * [initializer] function.
+         */
+        public inline fun int(size: Int, initializer: (Int) -> Int): IntBuffer =
+            IntBuffer(size, initializer)
+
+        /**
+         * Creates a [LongBuffer] with the specified [size], where each element is calculated by calling the specified
+         * [initializer] function.
+         */
+        public inline fun long(size: Int, initializer: (Int) -> Long): LongBuffer =
+            LongBuffer(size, initializer)
+
+
+        /**
+         * Creates a [FloatBuffer] with the specified [size], where each element is calculated by calling the specified
+         * [initializer] function.
+         */
+        public inline fun float(size: Int, initializer: (Int) -> Float): FloatBuffer =
+            FloatBuffer(size, initializer)
+
+
         /**
          * Create a boxing mutable buffer of given type
          */
@@ -161,11 +155,11 @@ public interface MutableBuffer<T> : Buffer<T> {
         @Suppress("UNCHECKED_CAST")
         public inline fun <T : Any> auto(type: KClass<out T>, size: Int, initializer: (Int) -> T): MutableBuffer<T> =
             when (type) {
-                Double::class -> RealBuffer(size) { initializer(it) as Double } as MutableBuffer<T>
-                Short::class -> ShortBuffer(size) { initializer(it) as Short } as MutableBuffer<T>
-                Int::class -> IntBuffer(size) { initializer(it) as Int } as MutableBuffer<T>
-                Float::class -> FloatBuffer(size) { initializer(it) as Float } as MutableBuffer<T>
-                Long::class -> LongBuffer(size) { initializer(it) as Long } as MutableBuffer<T>
+                Double::class -> real(size) { initializer(it) as Double } as MutableBuffer<T>
+                Short::class -> short(size) { initializer(it) as Short } as MutableBuffer<T>
+                Int::class -> int(size) { initializer(it) as Int } as MutableBuffer<T>
+                Float::class -> float(size) { initializer(it) as Float } as MutableBuffer<T>
+                Long::class -> long(size) { initializer(it) as Long } as MutableBuffer<T>
                 else -> boxing(size, initializer)
             }
 
@@ -178,13 +172,6 @@ public interface MutableBuffer<T> : Buffer<T> {
         @Suppress("UNCHECKED_CAST")
         public inline fun <reified T : Any> auto(size: Int, initializer: (Int) -> T): MutableBuffer<T> =
             auto(T::class, size, initializer)
-
-        /**
-         * Creates a [RealBuffer] with the specified [size], where each element is calculated by calling the specified
-         * [initializer] function.
-         */
-        public inline fun real(size: Int, initializer: (Int) -> Double): RealBuffer =
-            RealBuffer(size) { initializer(it) }
     }
 }
 
@@ -207,15 +194,6 @@ public inline class ListBuffer<T>(public val list: List<T>) : Buffer<T> {
  */
 public fun <T> List<T>.asBuffer(): ListBuffer<T> = ListBuffer(this)
 
-/**
- * Creates a new [ListBuffer] with the specified [size], where each element is calculated by calling the specified
- * [init] function.
- *
- * The function [init] is called for each array element sequentially starting from the first one.
- * It should return the value for an array element given its index.
- */
-public inline fun <T> ListBuffer(size: Int, init: (Int) -> T): ListBuffer<T> = List(size, init).asBuffer()
-
 /**
  * [MutableBuffer] implementation over [MutableList].
  *
@@ -236,6 +214,11 @@ public inline class MutableListBuffer<T>(public val list: MutableList<T>) : Muta
     override fun copy(): MutableBuffer<T> = MutableListBuffer(ArrayList(list))
 }
 
+/**
+ * Returns an [ListBuffer] that wraps the original list.
+ */
+public fun <T> MutableList<T>.asMutableBuffer(): MutableListBuffer<T> = MutableListBuffer(this)
+
 /**
  * [MutableBuffer] implementation over [Array].
  *
@@ -244,8 +227,7 @@ public inline class MutableListBuffer<T>(public val list: MutableList<T>) : Muta
  */
 public class ArrayBuffer<T>(internal val array: Array<T>) : MutableBuffer<T> {
     // Can't inline because array is invariant
-    override val size: Int
-        get() = array.size
+    override val size: Int get() = array.size
 
     override operator fun get(index: Int): T = array[index]
 
@@ -263,16 +245,6 @@ public class ArrayBuffer<T>(internal val array: Array<T>) : MutableBuffer<T> {
  */
 public fun <T> Array<T>.asBuffer(): ArrayBuffer<T> = ArrayBuffer(this)
 
-/**
- * Creates a new [ArrayBuffer] with the specified [size], where each element is calculated by calling the specified
- * [init] function.
- *
- * The function [init] is called for each array element sequentially starting from the first one.
- * It should return the value for an array element given its index.
- */
-public inline fun <reified T> ArrayBuffer(size: Int, init: (Int) -> T): ArrayBuffer<T> =
-    Array(size) { i -> init(i) }.asBuffer()
-
 /**
  * Immutable wrapper for [MutableBuffer].
  *
@@ -313,14 +285,4 @@ public class VirtualBuffer<T>(override val size: Int, private val generator: (In
 /**
  * Convert this buffer to read-only buffer.
  */
-public fun <T> Buffer<T>.asReadOnly(): Buffer<T> = if (this is MutableBuffer) ReadOnlyBuffer(this) else this
-
-/**
- * Typealias for buffer transformations.
- */
-public typealias BufferTransform<T, R> = (Buffer<T>) -> Buffer<R>
-
-/**
- * Typealias for buffer transformations with suspend function.
- */
-public typealias SuspendBufferTransform<T, R> = suspend (Buffer<T>) -> Buffer<R>
+public fun <T> Buffer<T>.asReadOnly(): Buffer<T> = if (this is MutableBuffer) ReadOnlyBuffer(this) else this
\ No newline at end of file
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/bufferOperation.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/bufferOperation.kt
index 459136631..4355ba17f 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/bufferOperation.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/bufferOperation.kt
@@ -1,7 +1,84 @@
 package space.kscience.kmath.structures
 
+import space.kscience.kmath.misc.UnstableKMathAPI
 
+/**
+ * Typealias for buffer transformations.
+ */
+public typealias BufferTransform<T, R> = (Buffer<T>) -> Buffer<R>
+
+/**
+ * Typealias for buffer transformations with suspend function.
+ */
+public typealias SuspendBufferTransform<T, R> = suspend (Buffer<T>) -> Buffer<R>
+
+
+/**
+ * Creates a sequence that returns all elements from this [Buffer].
+ */
+public fun <T> Buffer<T>.asSequence(): Sequence<T> = Sequence(::iterator)
+
+/**
+ * Creates an iterable that returns all elements from this [Buffer].
+ */
+public fun <T> Buffer<T>.asIterable(): Iterable<T> = Iterable(::iterator)
+
+/**
+ * Returns a new [List] containing all elements of this buffer.
+ */
+public fun <T> Buffer<T>.toList(): List<T> = when (this) {
+    is ArrayBuffer<T> -> array.toList()
+    is ListBuffer<T> -> list.toList()
+    is MutableListBuffer<T> -> list.toList()
+    else -> asSequence().toList()
+}
+
+/**
+ * Returns a new [MutableList] filled with all elements of this buffer.
+ * **NOTE:** this method uses a protective copy, so it should not be used in performance-critical code.
+ */
+@UnstableKMathAPI
+public fun <T> Buffer<T>.toMutableList(): MutableList<T> = when (this) {
+    is ArrayBuffer<T> -> array.toMutableList()
+    is ListBuffer<T> -> list.toMutableList()
+    is MutableListBuffer<T> -> list.toMutableList()
+    else -> MutableList(size, ::get)
+}
+
+/**
+ * Returns a new [Array] containing all elements of this buffer.
+ * **NOTE:** this method uses a protective copy, so it should not be used in performance-critical code.
+ */
+@UnstableKMathAPI
+public inline fun <reified T> Buffer<T>.toTypedArray(): Array<T> = Array(size, ::get)
+
+/**
+ * Create a new buffer from this one with the given mapping function.
+ * Provided [BufferFactory] is used to construct the new buffer.
+ */
 public inline fun <T : Any, reified R : Any> Buffer<T>.map(
     bufferFactory: BufferFactory<R> = Buffer.Companion::auto,
     crossinline block: (T) -> R,
-): Buffer<R> = bufferFactory(size) { block(get(it)) }
\ No newline at end of file
+): Buffer<R> = bufferFactory(size) { block(get(it)) }
+
+/**
+ * Create a new buffer from this one with the given indexed mapping function.
+ * Provided [BufferFactory] is used to construct the new buffer.
+ */
+public inline fun <T : Any, reified R : Any> Buffer<T>.mapIndexed(
+    bufferFactory: BufferFactory<R> = Buffer.Companion::auto,
+    crossinline block: (index: Int, value: T) -> R,
+): Buffer<R> = bufferFactory(size) { block(it, get(it)) }
+
+/**
+ * Zip two buffers using given [transform].
+ */
+@UnstableKMathAPI
+public inline fun <T1 : Any, T2 : Any, reified R : Any> Buffer<T1>.zip(
+    other: Buffer<T2>,
+    bufferFactory: BufferFactory<R> = Buffer.Companion::auto,
+    crossinline transform: (T1, T2) -> R,
+): Buffer<R> {
+    require(size == other.size) { "Buffer size mismatch in zip: expected $size but found ${other.size}" }
+    return bufferFactory(size) { transform(get(it), other[it]) }
+}
\ No newline at end of file
diff --git a/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/RealVector.kt b/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/RealVector.kt
index ee42fe404..8cc128947 100644
--- a/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/RealVector.kt
+++ b/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/RealVector.kt
@@ -1,8 +1,10 @@
 package space.kscience.kmath.real
 
 import space.kscience.kmath.linear.Point
+import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.operations.Norm
 import space.kscience.kmath.structures.Buffer
+import space.kscience.kmath.structures.MutableBuffer.Companion.real
 import space.kscience.kmath.structures.asBuffer
 import space.kscience.kmath.structures.asIterable
 import space.kscience.kmath.structures.indices
@@ -20,15 +22,16 @@ public operator fun Buffer.Companion.invoke(vararg doubles: Double): RealVector
 /**
  * Fill the vector of given [size] with given [value]
  */
+@UnstableKMathAPI
 public fun Buffer.Companion.same(size: Int, value: Number): RealVector = real(size) { value.toDouble() }
 
 // Transformation methods
 
 public inline fun RealVector.map(transform: (Double) -> Double): RealVector =
-    Buffer.real(size) { transform(get(it)) }
+    real(size) { transform(get(it)) }
 
 public inline fun RealVector.mapIndexed(transform: (index: Int, value: Double) -> Double): RealVector =
-    Buffer.real(size) { transform(it, get(it)) }
+    real(size) { transform(it, get(it)) }
 
 public operator fun RealVector.plus(other: RealVector): RealVector {
     require(size == other.size) { "Vector size $size expected but ${other.size} found" }
diff --git a/kmath-for-real/src/commonTest/kotlin/kaceince/kmath/real/RealVectorTest.kt b/kmath-for-real/src/commonTest/kotlin/kaceince/kmath/real/RealVectorTest.kt
index 59d55110f..60d85fda3 100644
--- a/kmath-for-real/src/commonTest/kotlin/kaceince/kmath/real/RealVectorTest.kt
+++ b/kmath-for-real/src/commonTest/kotlin/kaceince/kmath/real/RealVectorTest.kt
@@ -4,30 +4,30 @@ import space.kscience.kmath.linear.LinearSpace
 import space.kscience.kmath.linear.asMatrix
 import space.kscience.kmath.linear.transpose
 import space.kscience.kmath.real.plus
-import space.kscience.kmath.structures.Buffer
+import space.kscience.kmath.structures.RealBuffer
 import kotlin.test.Test
 import kotlin.test.assertEquals
 
 internal class RealVectorTest {
     @Test
     fun testSum() {
-        val vector1 = Buffer.real(5) { it.toDouble() }
-        val vector2 =  Buffer.real(5) { 5 - it.toDouble() }
+        val vector1 = RealBuffer(5) { it.toDouble() }
+        val vector2 = RealBuffer(5) { 5 - it.toDouble() }
         val sum = vector1 + vector2
         assertEquals(5.0, sum[2])
     }
 
     @Test
     fun testVectorToMatrix() {
-        val vector =  Buffer.real(5) { it.toDouble() }
+        val vector = RealBuffer(5) { it.toDouble() }
         val matrix = vector.asMatrix()
         assertEquals(4.0, matrix[4, 0])
     }
 
     @Test
     fun testDot() {
-        val vector1 =  Buffer.real(5) { it.toDouble() }
-        val vector2 =  Buffer.real(5) { 5 - it.toDouble() }
+        val vector1 = RealBuffer(5) { it.toDouble() }
+        val vector2 = RealBuffer(5) { 5 - it.toDouble() }
         val matrix1 = vector1.asMatrix()
         val matrix2 = vector2.asMatrix().transpose()
         val product = LinearSpace.real.run { matrix1 dot matrix2 }
diff --git a/kmath-histograms/src/commonMain/kotlin/space/kscience/kmath/histogram/Histogram.kt b/kmath-histograms/src/commonMain/kotlin/space/kscience/kmath/histogram/Histogram.kt
index 73b34783c..9ee4a6e1e 100644
--- a/kmath-histograms/src/commonMain/kotlin/space/kscience/kmath/histogram/Histogram.kt
+++ b/kmath-histograms/src/commonMain/kotlin/space/kscience/kmath/histogram/Histogram.kt
@@ -2,8 +2,8 @@ package space.kscience.kmath.histogram
 
 import space.kscience.kmath.domains.Domain
 import space.kscience.kmath.linear.Point
-import space.kscience.kmath.structures.ArrayBuffer
 import space.kscience.kmath.structures.RealBuffer
+import space.kscience.kmath.structures.asBuffer
 
 /**
  * The binned data element. Could be a histogram bin with a number of counts or an artificial construct
@@ -40,7 +40,7 @@ public fun interface HistogramBuilder<T : Any>  {
 
 public fun <T : Any, B : Bin<T>> HistogramBuilder<T>.put(point: Point<out T>): Unit = putValue(point, 1.0)
 
-public fun <T : Any> HistogramBuilder<T>.put(vararg point: T): Unit = put(ArrayBuffer(point))
+public fun <T : Any> HistogramBuilder<T>.put(vararg point: T): Unit = put(point.asBuffer())
 
 public fun HistogramBuilder<Double>.put(vararg point: Number): Unit =
     put(RealBuffer(point.map { it.toDouble() }.toDoubleArray()))
diff --git a/kmath-stat/src/commonMain/kotlin/space/kscience/kmath/stat/Distribution.kt b/kmath-stat/src/commonMain/kotlin/space/kscience/kmath/stat/Distribution.kt
index fa38dd9e4..b5b6db1d8 100644
--- a/kmath-stat/src/commonMain/kotlin/space/kscience/kmath/stat/Distribution.kt
+++ b/kmath-stat/src/commonMain/kotlin/space/kscience/kmath/stat/Distribution.kt
@@ -4,6 +4,7 @@ import space.kscience.kmath.chains.Chain
 import space.kscience.kmath.chains.collect
 import space.kscience.kmath.structures.Buffer
 import space.kscience.kmath.structures.BufferFactory
+import space.kscience.kmath.structures.RealBuffer
 
 public interface Sampler<T : Any> {
     public fun sample(generator: RandomGenerator): Chain<T>
@@ -74,4 +75,4 @@ public fun <T : Any> Sampler<T>.sampleBuffer(
  * Generate a bunch of samples from real distributions
  */
 public fun Sampler<Double>.sampleBuffer(generator: RandomGenerator, size: Int): Chain<Buffer<Double>> =
-    sampleBuffer(generator, size, Buffer.Companion::real)
+    sampleBuffer(generator, size, ::RealBuffer)
-- 
2.34.1


From d9743978ab5739e087f23bbe1c86240231ca5b10 Mon Sep 17 00:00:00 2001
From: Alexander Nozik <altavir@gmail.com>
Date: Mon, 15 Mar 2021 14:26:59 +0300
Subject: [PATCH 33/37] Reformat code

---
 .../kmath/expressions/DifferentiableExpression.kt |  2 +-
 .../kscience/kmath/expressions/Expression.kt      |  2 +-
 .../expressions/FunctionalExpressionAlgebra.kt    |  2 +-
 .../kscience/kmath/linear/BufferedLinearSpace.kt  |  2 +-
 .../space/kscience/kmath/linear/LinearSpace.kt    |  2 +-
 .../space/kscience/kmath/linear/VirtualMatrix.kt  |  2 +-
 .../kotlin/space/kscience/kmath/nd/NDAlgebra.kt   | 15 ++++++++-------
 .../kscience/kmath/operations/AlgebraElements.kt  |  2 +-
 .../kmath/operations/algebraExtensions.kt         |  4 ++--
 .../kscience/kmath/structures/BufferAccessor2D.kt |  4 ++--
 .../kscience/kmath/structures/FloatBuffer.kt      |  2 +-
 .../space/kscience/kmath/structures/IntBuffer.kt  |  2 +-
 .../space/kscience/kmath/structures/LongBuffer.kt |  2 +-
 .../kscience/kmath/structures/MemoryBuffer.kt     |  4 ++--
 .../space/kscience/kmath/structures/RealBuffer.kt |  2 +-
 .../kscience/kmath/structures/ShortBuffer.kt      |  2 +-
 .../kscience/kmath/linear/RealLUSolverTest.kt     |  6 +++---
 .../kmath/structures/NumberNDFieldTest.kt         |  2 +-
 18 files changed, 30 insertions(+), 29 deletions(-)

diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/DifferentiableExpression.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/DifferentiableExpression.kt
index 508a62aca..5cbc4dbf4 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/DifferentiableExpression.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/DifferentiableExpression.kt
@@ -28,7 +28,7 @@ public fun <T, R : Expression<T>> DifferentiableExpression<T, R>.derivative(name
 /**
  * A [DifferentiableExpression] that defines only first derivatives
  */
-public abstract class FirstDerivativeExpression<T, R : Expression<T>> : DifferentiableExpression<T,R> {
+public abstract class FirstDerivativeExpression<T, R : Expression<T>> : DifferentiableExpression<T, R> {
     /**
      * Returns first derivative of this expression by given [symbol].
      */
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/Expression.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/Expression.kt
index 231bbdab1..5ba24aa62 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/Expression.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/Expression.kt
@@ -95,7 +95,7 @@ public fun <T, E> ExpressionAlgebra<T, E>.bindSymbol(symbol: Symbol): E =
 /**
  * A delegate to create a symbol with a string identity in this scope
  */
-public val symbol: ReadOnlyProperty<Any?, Symbol>  = ReadOnlyProperty { _, property ->
+public val symbol: ReadOnlyProperty<Any?, Symbol> = ReadOnlyProperty { _, property ->
     StringSymbol(property.name)
 }
 
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/FunctionalExpressionAlgebra.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/FunctionalExpressionAlgebra.kt
index 880f13a3e..cca75754f 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/FunctionalExpressionAlgebra.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/FunctionalExpressionAlgebra.kt
@@ -98,7 +98,7 @@ public open class FunctionalExpressionRing<T, A : Ring<T>>(
         super<FunctionalExpressionGroup>.binaryOperationFunction(operation)
 }
 
-public open class FunctionalExpressionField<T, A:  Field<T>>(
+public open class FunctionalExpressionField<T, A : Field<T>>(
     algebra: A,
 ) : FunctionalExpressionRing<T, A>(algebra), Field<Expression<T>>,
     ScaleOperations<Expression<T>> {
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/BufferedLinearSpace.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/BufferedLinearSpace.kt
index 5814ab35c..fe92a711a 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/BufferedLinearSpace.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/BufferedLinearSpace.kt
@@ -48,7 +48,7 @@ public class BufferedLinearSpace<T : Any, A : Ring<T>>(
     override fun Matrix<T>.dot(other: Matrix<T>): Matrix<T> {
         require(colNum == other.rowNum) { "Matrix dot operation dimension mismatch: ($rowNum, $colNum) x (${other.rowNum}, ${other.colNum})" }
         return elementAlgebra {
-            val rows = this@dot.rows.map{it.linearize()}
+            val rows = this@dot.rows.map { it.linearize() }
             val columns = other.columns.map { it.linearize() }
             buildMatrix(rowNum, other.colNum) { i, j ->
                 val r = rows[i]
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpace.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpace.kt
index cf8564e08..740ad12eb 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpace.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpace.kt
@@ -175,7 +175,7 @@ public interface LinearSpace<T : Any, out A : Ring<T>> {
         public fun <T : Any, A : Ring<T>> buffered(
             algebra: A,
             bufferFactory: BufferFactory<T> = Buffer.Companion::boxing,
-        ): LinearSpace<T, A> = BufferedLinearSpace(algebra,bufferFactory)
+        ): LinearSpace<T, A> = BufferedLinearSpace(algebra, bufferFactory)
 
         public val real: LinearSpace<Double, RealField> = buffered(RealField, ::RealBuffer)
 
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/VirtualMatrix.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/VirtualMatrix.kt
index 7f0451946..8efa08f81 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/VirtualMatrix.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/VirtualMatrix.kt
@@ -10,7 +10,7 @@ import space.kscience.kmath.nd.NDStructure
 public class VirtualMatrix<T : Any>(
     override val rowNum: Int,
     override val colNum: Int,
-    public val generator: (i: Int, j: Int) -> T
+    public val generator: (i: Int, j: Int) -> T,
 ) : Matrix<T> {
 
     override val shape: IntArray get() = intArrayOf(rowNum, colNum)
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/NDAlgebra.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/NDAlgebra.kt
index e3ffae74b..81e1e988a 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/NDAlgebra.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/NDAlgebra.kt
@@ -19,7 +19,7 @@ public class ShapeMismatchException(public val expected: IntArray, public val ac
  * @param C the type of the element context.
  * @param N the type of the structure.
  */
-public interface NDAlgebra<T, C: Algebra<T>> {
+public interface NDAlgebra<T, C : Algebra<T>> {
     /**
      * The shape of ND-structures this algebra operates on.
      */
@@ -65,11 +65,12 @@ public interface NDAlgebra<T, C: Algebra<T>> {
  * @param structures the structures to check.
  * @return the array of valid structures.
  */
-internal fun <T, C: Algebra<T>> NDAlgebra<T, C>.checkShape(vararg structures: NDStructure<T>): Array<out NDStructure<T>> = structures
-    .map(NDStructure<T>::shape)
-    .singleOrNull { !shape.contentEquals(it) }
-    ?.let<IntArray, Array<out NDStructure<T>>> { throw ShapeMismatchException(shape, it) }
-    ?: structures
+internal fun <T, C : Algebra<T>> NDAlgebra<T, C>.checkShape(vararg structures: NDStructure<T>): Array<out NDStructure<T>> =
+    structures
+        .map(NDStructure<T>::shape)
+        .singleOrNull { !shape.contentEquals(it) }
+        ?.let<IntArray, Array<out NDStructure<T>>> { throw ShapeMismatchException(shape, it) }
+        ?: structures
 
 /**
  * Checks if given element is consistent with this context.
@@ -77,7 +78,7 @@ internal fun <T, C: Algebra<T>> NDAlgebra<T, C>.checkShape(vararg structures: ND
  * @param element the structure to check.
  * @return the valid structure.
  */
-internal fun <T, C: Algebra<T>> NDAlgebra<T, C>.checkShape(element: NDStructure<T>): NDStructure<T> {
+internal fun <T, C : Algebra<T>> NDAlgebra<T, C>.checkShape(element: NDStructure<T>): NDStructure<T> {
     if (!element.shape.contentEquals(shape)) throw ShapeMismatchException(shape, element.shape)
     return element
 }
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/AlgebraElements.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/AlgebraElements.kt
index 3e42ac094..b2b5911df 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/AlgebraElements.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/AlgebraElements.kt
@@ -41,7 +41,7 @@ public interface AlgebraElement<T, C : Algebra<T>> {
  */
 @UnstableKMathAPI
 public operator fun <T : AlgebraElement<T, S>, S : NumbersAddOperations<T>> T.minus(b: T): T =
-    context.add(this, context.run { -b})
+    context.add(this, context.run { -b })
 
 /**
  * Adds element to this one.
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/algebraExtensions.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/algebraExtensions.kt
index 52a0dec6f..9a395b0f4 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/algebraExtensions.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/algebraExtensions.kt
@@ -71,7 +71,7 @@ public fun <T> Sequence<T>.sumWith(space: Group<T>): T = space.sum(this)
  * @return the average value.
  * @author Iaroslav Postovalov
  */
-public fun <T, S> Iterable<T>.averageWith(space: S): T  where S : Group<T>, S : ScaleOperations<T>  =
+public fun <T, S> Iterable<T>.averageWith(space: S): T where S : Group<T>, S : ScaleOperations<T> =
     space.average(this)
 
 /**
@@ -82,7 +82,7 @@ public fun <T, S> Iterable<T>.averageWith(space: S): T  where S : Group<T>, S :
  * @return the average value.
  * @author Iaroslav Postovalov
  */
-public fun <T, S> Sequence<T>.averageWith(space: S): T  where S : Group<T>, S : ScaleOperations<T>  =
+public fun <T, S> Sequence<T>.averageWith(space: S): T where S : Group<T>, S : ScaleOperations<T> =
     space.average(this)
 
 //TODO optimized power operation
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/BufferAccessor2D.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/BufferAccessor2D.kt
index 0910b2034..c65af7a98 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/BufferAccessor2D.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/BufferAccessor2D.kt
@@ -13,10 +13,10 @@ internal class BufferAccessor2D<T : Any>(
     public val colNum: Int,
     val factory: MutableBufferFactory<T>,
 ) {
-    public operator fun Buffer<T>.get(i: Int, j: Int): T = get(i*colNum + j)
+    public operator fun Buffer<T>.get(i: Int, j: Int): T = get(i * colNum + j)
 
     public operator fun MutableBuffer<T>.set(i: Int, j: Int, value: T) {
-        set(i*colNum + j, value)
+        set(i * colNum + j, value)
     }
 
     public inline fun create(crossinline init: (i: Int, j: Int) -> T): MutableBuffer<T> =
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/FloatBuffer.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/FloatBuffer.kt
index 9fc7d55f3..5c4ec3b05 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/FloatBuffer.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/FloatBuffer.kt
@@ -38,7 +38,7 @@ public fun FloatBuffer(vararg floats: Float): FloatBuffer = FloatBuffer(floats)
 /**
  * Returns a new [FloatArray] containing all of the elements of this [Buffer].
  */
-public fun Buffer<Float>.toFloatArray(): FloatArray = when(this) {
+public fun Buffer<Float>.toFloatArray(): FloatArray = when (this) {
     is FloatBuffer -> array.copyOf()
     else -> FloatArray(size, ::get)
 }
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/IntBuffer.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/IntBuffer.kt
index d3d0f79a5..32dfcf9aa 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/IntBuffer.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/IntBuffer.kt
@@ -37,7 +37,7 @@ public fun IntBuffer(vararg ints: Int): IntBuffer = IntBuffer(ints)
 /**
  * Returns a new [IntArray] containing all of the elements of this [Buffer].
  */
-public fun Buffer<Int>.toIntArray(): IntArray = when(this) {
+public fun Buffer<Int>.toIntArray(): IntArray = when (this) {
     is IntBuffer -> array.copyOf()
     else -> IntArray(size, ::get)
 }
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/LongBuffer.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/LongBuffer.kt
index fec358421..48b1d7a7b 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/LongBuffer.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/LongBuffer.kt
@@ -37,7 +37,7 @@ public fun LongBuffer(vararg longs: Long): LongBuffer = LongBuffer(longs)
 /**
  * Returns a new [LongArray] containing all of the elements of this [Buffer].
  */
-public fun Buffer<Long>.toLongArray(): LongArray = when(this) {
+public fun Buffer<Long>.toLongArray(): LongArray = when (this) {
     is LongBuffer -> array.copyOf()
     else -> LongArray(size, ::get)
 }
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/MemoryBuffer.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/MemoryBuffer.kt
index 418adb537..50a2db590 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/MemoryBuffer.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/MemoryBuffer.kt
@@ -24,7 +24,7 @@ public open class MemoryBuffer<T : Any>(protected val memory: Memory, protected
         public inline fun <T : Any> create(
             spec: MemorySpec<T>,
             size: Int,
-            initializer: (Int) -> T
+            initializer: (Int) -> T,
         ): MemoryBuffer<T> = MutableMemoryBuffer(Memory.allocate(size * spec.objectSize), spec).also { buffer ->
             (0 until size).forEach { buffer[it] = initializer(it) }
         }
@@ -53,7 +53,7 @@ public class MutableMemoryBuffer<T : Any>(memory: Memory, spec: MemorySpec<T>) :
         public inline fun <T : Any> create(
             spec: MemorySpec<T>,
             size: Int,
-            initializer: (Int) -> T
+            initializer: (Int) -> T,
         ): MutableMemoryBuffer<T> = MutableMemoryBuffer(Memory.allocate(size * spec.objectSize), spec).also { buffer ->
             (0 until size).forEach { buffer[it] = initializer(it) }
         }
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/RealBuffer.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/RealBuffer.kt
index 01b533138..b56c03b76 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/RealBuffer.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/RealBuffer.kt
@@ -42,7 +42,7 @@ public fun RealBuffer.contentEquals(vararg doubles: Double): Boolean = array.con
 /**
  * Returns a new [DoubleArray] containing all of the elements of this [Buffer].
  */
-public fun Buffer<Double>.toDoubleArray(): DoubleArray = when(this) {
+public fun Buffer<Double>.toDoubleArray(): DoubleArray = when (this) {
     is RealBuffer -> array.copyOf()
     else -> DoubleArray(size, ::get)
 }
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/ShortBuffer.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/ShortBuffer.kt
index 77f128403..7832bb863 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/ShortBuffer.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/ShortBuffer.kt
@@ -35,7 +35,7 @@ public fun ShortBuffer(vararg shorts: Short): ShortBuffer = ShortBuffer(shorts)
 /**
  * Returns a new [ShortArray] containing all of the elements of this [Buffer].
  */
-public fun Buffer<Short>.toShortArray(): ShortArray = when(this) {
+public fun Buffer<Short>.toShortArray(): ShortArray = when (this) {
     is ShortBuffer -> array.copyOf()
     else -> ShortArray(size, ::get)
 }
diff --git a/kmath-core/src/commonTest/kotlin/space/kscience/kmath/linear/RealLUSolverTest.kt b/kmath-core/src/commonTest/kotlin/space/kscience/kmath/linear/RealLUSolverTest.kt
index fb90b5e11..e6efc6a8a 100644
--- a/kmath-core/src/commonTest/kotlin/space/kscience/kmath/linear/RealLUSolverTest.kt
+++ b/kmath-core/src/commonTest/kotlin/space/kscience/kmath/linear/RealLUSolverTest.kt
@@ -17,7 +17,7 @@ class RealLUSolverTest {
     @Test
     fun testDecomposition() {
         LinearSpace.real.run {
-            val matrix = matrix(2,2)(
+            val matrix = matrix(2, 2)(
                 3.0, 1.0,
                 2.0, 3.0
             )
@@ -33,14 +33,14 @@ class RealLUSolverTest {
 
     @Test
     fun testInvert() {
-        val matrix = LinearSpace.real.matrix(2,2)(
+        val matrix = LinearSpace.real.matrix(2, 2)(
             3.0, 1.0,
             1.0, 3.0
         )
 
         val inverted = LinearSpace.real.inverseWithLup(matrix)
 
-        val expected = LinearSpace.real.matrix(2,2)(
+        val expected = LinearSpace.real.matrix(2, 2)(
             0.375, -0.125,
             -0.125, 0.375
         )
diff --git a/kmath-core/src/commonTest/kotlin/space/kscience/kmath/structures/NumberNDFieldTest.kt b/kmath-core/src/commonTest/kotlin/space/kscience/kmath/structures/NumberNDFieldTest.kt
index dd7871f9a..e9e6e92fb 100644
--- a/kmath-core/src/commonTest/kotlin/space/kscience/kmath/structures/NumberNDFieldTest.kt
+++ b/kmath-core/src/commonTest/kotlin/space/kscience/kmath/structures/NumberNDFieldTest.kt
@@ -11,7 +11,7 @@ import kotlin.test.assertEquals
 
 @Suppress("UNUSED_VARIABLE")
 class NumberNDFieldTest {
-    val algebra = NDAlgebra.real(3,3)
+    val algebra = NDAlgebra.real(3, 3)
     val array1 = algebra.produce { (i, j) -> (i + j).toDouble() }
     val array2 = algebra.produce { (i, j) -> (i - j).toDouble() }
 
-- 
2.34.1


From 71ed56c2b69868948c39dba7dd22c9a4692f8a5c Mon Sep 17 00:00:00 2001
From: Alexander Nozik <altavir@gmail.com>
Date: Mon, 15 Mar 2021 16:46:12 +0300
Subject: [PATCH 34/37] Move features to scopes

---
 .../kscience/kmath/commons/linear/CMMatrix.kt | 82 ++++++++++---------
 .../kscience/kmath/linear/LinearSpace.kt      | 21 ++---
 .../space/kscience/kmath/nd/NDAlgebra.kt      | 25 ++++++
 .../kscience/kmath/ejml/EjmlLinearSpace.kt    | 74 +++++++++++++++++
 .../space/kscience/kmath/ejml/EjmlMatrix.kt   | 69 +---------------
 .../kscience/kmath/ejml/EjmlMatrixTest.kt     |  9 +-
 6 files changed, 156 insertions(+), 124 deletions(-)

diff --git 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
index 5f632491c..5b45c2e51 100644
--- 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
@@ -13,44 +13,6 @@ public class CMMatrix(public val origin: RealMatrix) : Matrix<Double> {
     public override val rowNum: Int get() = origin.rowDimension
     public override val colNum: Int get() = origin.columnDimension
 
-    @UnstableKMathAPI
-    override fun <T : Any> getFeature(type: KClass<T>): T? = when (type) {
-        DiagonalFeature::class -> if (origin is DiagonalMatrix) DiagonalFeature else null
-
-        DeterminantFeature::class, LupDecompositionFeature::class -> object :
-            DeterminantFeature<Double>,
-            LupDecompositionFeature<Double> {
-            private val lup by lazy { LUDecomposition(origin) }
-            override val determinant: Double by lazy { lup.determinant }
-            override val l: Matrix<Double> by lazy { CMMatrix(lup.l) + LFeature }
-            override val u: Matrix<Double> by lazy { CMMatrix(lup.u) + UFeature }
-            override val p: Matrix<Double> by lazy { CMMatrix(lup.p) }
-        }
-
-        CholeskyDecompositionFeature::class -> object : CholeskyDecompositionFeature<Double> {
-            override val l: Matrix<Double> by lazy {
-                val cholesky = CholeskyDecomposition(origin)
-                CMMatrix(cholesky.l) + LFeature
-            }
-        }
-
-        QRDecompositionFeature::class -> object : QRDecompositionFeature<Double> {
-            private val qr by lazy { QRDecomposition(origin) }
-            override val q: Matrix<Double> by lazy { CMMatrix(qr.q) + OrthogonalFeature }
-            override val r: Matrix<Double> by lazy { CMMatrix(qr.r) + UFeature }
-        }
-
-        SingularValueDecompositionFeature::class -> object : SingularValueDecompositionFeature<Double> {
-            private val sv by lazy { SingularValueDecomposition(origin) }
-            override val u: Matrix<Double> by lazy { CMMatrix(sv.u) }
-            override val s: Matrix<Double> by lazy { CMMatrix(sv.s) }
-            override val v: Matrix<Double> by lazy { CMMatrix(sv.v) }
-            override val singularValues: Point<Double> by lazy { RealBuffer(sv.singularValues) }
-        }
-
-        else -> null
-    }?.let(type::cast)
-
     public override operator fun get(i: Int, j: Int): Double = origin.getEntry(i, j)
 
     override fun equals(other: Any?): Boolean {
@@ -134,6 +96,50 @@ public object CMLinearSpace : LinearSpace<Double, RealField> {
 
     override fun Double.times(v: Point<Double>): CMVector =
         v * this
+
+    @UnstableKMathAPI
+    override fun <F : Any> getFeature(structure: Matrix<Double>, type: KClass<F>): F? {
+        //Return the feature if it is intrinsic to the structure
+        structure.getFeature(type)?.let { return it }
+
+        val origin = structure.toCM().origin
+        
+        return when (type) {
+            DiagonalFeature::class -> if (origin is DiagonalMatrix) DiagonalFeature else null
+
+            DeterminantFeature::class, LupDecompositionFeature::class -> object :
+                DeterminantFeature<Double>,
+                LupDecompositionFeature<Double> {
+                private val lup by lazy { LUDecomposition(origin) }
+                override val determinant: Double by lazy { lup.determinant }
+                override val l: Matrix<Double> by lazy { CMMatrix(lup.l) + LFeature }
+                override val u: Matrix<Double> by lazy { CMMatrix(lup.u) + UFeature }
+                override val p: Matrix<Double> by lazy { CMMatrix(lup.p) }
+            }
+
+            CholeskyDecompositionFeature::class -> object : CholeskyDecompositionFeature<Double> {
+                override val l: Matrix<Double> by lazy {
+                    val cholesky = CholeskyDecomposition(origin)
+                    CMMatrix(cholesky.l) + LFeature
+                }
+            }
+
+            QRDecompositionFeature::class -> object : QRDecompositionFeature<Double> {
+                private val qr by lazy { QRDecomposition(origin) }
+                override val q: Matrix<Double> by lazy { CMMatrix(qr.q) + OrthogonalFeature }
+                override val r: Matrix<Double> by lazy { CMMatrix(qr.r) + UFeature }
+            }
+
+            SingularValueDecompositionFeature::class -> object : SingularValueDecompositionFeature<Double> {
+                private val sv by lazy { SingularValueDecomposition(origin) }
+                override val u: Matrix<Double> by lazy { CMMatrix(sv.u) }
+                override val s: Matrix<Double> by lazy { CMMatrix(sv.s) }
+                override val v: Matrix<Double> by lazy { CMMatrix(sv.v) }
+                override val singularValues: Point<Double> by lazy { RealBuffer(sv.singularValues) }
+            }
+            else -> null
+        }?.let(type::cast)
+    }
 }
 
 public operator fun CMMatrix.plus(other: CMMatrix): CMMatrix =
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpace.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpace.kt
index 740ad12eb..e8c7d119b 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpace.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpace.kt
@@ -156,16 +156,15 @@ public interface LinearSpace<T : Any, out A : Ring<T>> {
     public operator fun T.times(v: Point<T>): Point<T> = v * this
 
     /**
-     * Gets a feature from the matrix. This function may return some additional features to
-     * [space.kscience.kmath.nd.NDStructure.getFeature].
+     * Get a feature of the structure in this scope. Structure features take precedence other context features
      *
      * @param F the type of feature.
-     * @param m the matrix.
+     * @param structure the structure.
      * @param type the [KClass] instance of [F].
      * @return a feature object or `null` if it isn't present.
      */
     @UnstableKMathAPI
-    public fun <F : Any> getFeature(m: Matrix<T>, type: KClass<F>): F? = m.getFeature(type)
+    public fun <F : Any> getFeature(structure: Matrix<T>, type: KClass<F>): F? = structure.getFeature(type)
 
     public companion object {
 
@@ -187,19 +186,17 @@ public interface LinearSpace<T : Any, out A : Ring<T>> {
     }
 }
 
-public operator fun <LS : LinearSpace<*, *>, R> LS.invoke(block: LS.() -> R): R = run(block)
-
 /**
- * Gets a feature from the matrix. This function may return some additional features to
- * [space.kscience.kmath.nd.NDStructure.getFeature].
+ * Get a feature of the structure in this scope. Structure features take precedence other context features
  *
  * @param T the type of items in the matrices.
- * @param M the type of operated matrices.
  * @param F the type of feature.
- * @receiver the [LinearSpace] of [T].
- * @param m the matrix.
  * @return a feature object or `null` if it isn't present.
  */
 @UnstableKMathAPI
-public inline fun <T : Any, reified F : Any> LinearSpace<T, *>.getFeature(m: Matrix<T>): F? = getFeature(m, F::class)
+public inline fun <T : Any, reified F : Any> LinearSpace<T, *>.getFeature(structure: Matrix<T>): F? =
+    getFeature(structure, F::class)
+
+
+public operator fun <LS : LinearSpace<*, *>, R> LS.invoke(block: LS.() -> R): R = run(block)
 
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/NDAlgebra.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/NDAlgebra.kt
index 81e1e988a..5514a8f0f 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/NDAlgebra.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/NDAlgebra.kt
@@ -1,7 +1,9 @@
 package space.kscience.kmath.nd
 
+import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.operations.*
 import space.kscience.kmath.structures.*
+import kotlin.reflect.KClass
 
 /**
  * An exception is thrown when the expected ans actual shape of NDArray differs.
@@ -56,9 +58,32 @@ public interface NDAlgebra<T, C : Algebra<T>> {
     public operator fun Function1<T, T>.invoke(structure: NDStructure<T>): NDStructure<T> =
         structure.map { value -> this@invoke(value) }
 
+    /**
+     * Get a feature of the structure in this scope. Structure features take precedence other context features
+     *
+     * @param F the type of feature.
+     * @param structure the structure.
+     * @param type the [KClass] instance of [F].
+     * @return a feature object or `null` if it isn't present.
+     */
+    @UnstableKMathAPI
+    public fun <F : Any> getFeature(structure: NDStructure<T>, type: KClass<F>): F? = structure.getFeature(type)
+
     public companion object
 }
 
+
+/**
+ * Get a feature of the structure in this scope. Structure features take precedence other context features
+ *
+ * @param T the type of items in the matrices.
+ * @param F the type of feature.
+ * @return a feature object or `null` if it isn't present.
+ */
+@UnstableKMathAPI
+public inline fun <T : Any, reified F : Any> NDAlgebra<T, *>.getFeature(structure: NDStructure<T>): F? =
+    getFeature(structure, F::class)
+
 /**
  * Checks if given elements are consistent with this context.
  *
diff --git a/kmath-ejml/src/main/kotlin/space/kscience/kmath/ejml/EjmlLinearSpace.kt b/kmath-ejml/src/main/kotlin/space/kscience/kmath/ejml/EjmlLinearSpace.kt
index eecd88681..452280295 100644
--- a/kmath-ejml/src/main/kotlin/space/kscience/kmath/ejml/EjmlLinearSpace.kt
+++ b/kmath-ejml/src/main/kotlin/space/kscience/kmath/ejml/EjmlLinearSpace.kt
@@ -1,10 +1,14 @@
 package space.kscience.kmath.ejml
 
+import org.ejml.dense.row.factory.DecompositionFactory_DDRM
 import org.ejml.simple.SimpleMatrix
 import space.kscience.kmath.linear.*
 import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.nd.getFeature
 import space.kscience.kmath.operations.RealField
+import space.kscience.kmath.structures.RealBuffer
+import kotlin.reflect.KClass
+import kotlin.reflect.cast
 
 /**
  * Represents context of basic operations operating with [EjmlMatrix].
@@ -83,6 +87,76 @@ public object EjmlLinearSpace : LinearSpace<Double, RealField> {
 
     override fun Double.times(v: Point<Double>): EjmlVector =
         v.toEjml().origin.scale(this).wrapVector()
+
+    @UnstableKMathAPI
+    override fun <F : Any> getFeature(structure: Matrix<Double>, type: KClass<F>): F? {
+        //Return the feature if it is intrinsic to the structure
+        structure.getFeature(type)?.let { return it }
+
+        val origin = structure.toEjml().origin
+
+        return when (type) {
+            InverseMatrixFeature::class -> object : InverseMatrixFeature<Double> {
+                override val inverse: Matrix<Double> by lazy { EjmlMatrix(origin.invert()) }
+            }
+
+            DeterminantFeature::class -> object : DeterminantFeature<Double> {
+                override val determinant: Double by lazy(origin::determinant)
+            }
+
+            SingularValueDecompositionFeature::class -> object : SingularValueDecompositionFeature<Double> {
+                private val svd by lazy {
+                    DecompositionFactory_DDRM.svd(origin.numRows(), origin.numCols(), true, true, false)
+                        .apply { decompose(origin.ddrm.copy()) }
+                }
+
+                override val u: Matrix<Double> by lazy { EjmlMatrix(SimpleMatrix(svd.getU(null, false))) }
+                override val s: Matrix<Double> by lazy { EjmlMatrix(SimpleMatrix(svd.getW(null))) }
+                override val v: Matrix<Double> by lazy { EjmlMatrix(SimpleMatrix(svd.getV(null, false))) }
+                override val singularValues: Point<Double> by lazy { RealBuffer(svd.singularValues) }
+            }
+
+            QRDecompositionFeature::class -> object : QRDecompositionFeature<Double> {
+                private val qr by lazy {
+                    DecompositionFactory_DDRM.qr().apply { decompose(origin.ddrm.copy()) }
+                }
+
+                override val q: Matrix<Double> by lazy {
+                    EjmlMatrix(SimpleMatrix(qr.getQ(null, false))) + OrthogonalFeature
+                }
+
+                override val r: Matrix<Double> by lazy { EjmlMatrix(SimpleMatrix(qr.getR(null, false))) + UFeature }
+            }
+
+            CholeskyDecompositionFeature::class -> object : CholeskyDecompositionFeature<Double> {
+                override val l: Matrix<Double> by lazy {
+                    val cholesky =
+                        DecompositionFactory_DDRM.chol(structure.rowNum, true).apply { decompose(origin.ddrm.copy()) }
+
+                    EjmlMatrix(SimpleMatrix(cholesky.getT(null))) + LFeature
+                }
+            }
+
+            LupDecompositionFeature::class -> object : LupDecompositionFeature<Double> {
+                private val lup by lazy {
+                    DecompositionFactory_DDRM.lu(origin.numRows(), origin.numCols())
+                        .apply { decompose(origin.ddrm.copy()) }
+                }
+
+                override val l: Matrix<Double> by lazy {
+                    EjmlMatrix(SimpleMatrix(lup.getLower(null))) + LFeature
+                }
+
+                override val u: Matrix<Double> by lazy {
+                    EjmlMatrix(SimpleMatrix(lup.getUpper(null))) + UFeature
+                }
+
+                override val p: Matrix<Double> by lazy { EjmlMatrix(SimpleMatrix(lup.getRowPivot(null))) }
+            }
+
+            else -> null
+        }?.let(type::cast)
+    }
 }
 
 /**
diff --git a/kmath-ejml/src/main/kotlin/space/kscience/kmath/ejml/EjmlMatrix.kt b/kmath-ejml/src/main/kotlin/space/kscience/kmath/ejml/EjmlMatrix.kt
index a1984fa31..5f93af729 100644
--- a/kmath-ejml/src/main/kotlin/space/kscience/kmath/ejml/EjmlMatrix.kt
+++ b/kmath-ejml/src/main/kotlin/space/kscience/kmath/ejml/EjmlMatrix.kt
@@ -1,13 +1,8 @@
 package space.kscience.kmath.ejml
 
-import org.ejml.dense.row.factory.DecompositionFactory_DDRM
 import org.ejml.simple.SimpleMatrix
-import space.kscience.kmath.linear.*
-import space.kscience.kmath.misc.UnstableKMathAPI
+import space.kscience.kmath.linear.Matrix
 import space.kscience.kmath.nd.NDStructure
-import space.kscience.kmath.structures.RealBuffer
-import kotlin.reflect.KClass
-import kotlin.reflect.cast
 
 /**
  * Represents featured matrix over EJML [SimpleMatrix].
@@ -19,68 +14,6 @@ public class EjmlMatrix(public val origin: SimpleMatrix) : Matrix<Double> {
     public override val rowNum: Int get() = origin.numRows()
     public override val colNum: Int get() = origin.numCols()
 
-    @UnstableKMathAPI
-    public override fun <T : Any> getFeature(type: KClass<T>): T? = when (type) {
-        InverseMatrixFeature::class -> object : InverseMatrixFeature<Double> {
-            override val inverse: Matrix<Double> by lazy { EjmlMatrix(origin.invert()) }
-        }
-
-        DeterminantFeature::class -> object : DeterminantFeature<Double> {
-            override val determinant: Double by lazy(origin::determinant)
-        }
-
-        SingularValueDecompositionFeature::class -> object : SingularValueDecompositionFeature<Double> {
-            private val svd by lazy {
-                DecompositionFactory_DDRM.svd(origin.numRows(), origin.numCols(), true, true, false)
-                    .apply { decompose(origin.ddrm.copy()) }
-            }
-
-            override val u: Matrix<Double> by lazy { EjmlMatrix(SimpleMatrix(svd.getU(null, false))) }
-            override val s: Matrix<Double> by lazy { EjmlMatrix(SimpleMatrix(svd.getW(null))) }
-            override val v: Matrix<Double> by lazy { EjmlMatrix(SimpleMatrix(svd.getV(null, false))) }
-            override val singularValues: Point<Double> by lazy { RealBuffer(svd.singularValues) }
-        }
-
-        QRDecompositionFeature::class -> object : QRDecompositionFeature<Double> {
-            private val qr by lazy {
-                DecompositionFactory_DDRM.qr().apply { decompose(origin.ddrm.copy()) }
-            }
-
-            override val q: Matrix<Double> by lazy {
-                EjmlMatrix(SimpleMatrix(qr.getQ(null, false))) + OrthogonalFeature
-            }
-
-            override val r: Matrix<Double> by lazy { EjmlMatrix(SimpleMatrix(qr.getR(null, false))) + UFeature }
-        }
-
-        CholeskyDecompositionFeature::class -> object : CholeskyDecompositionFeature<Double> {
-            override val l: Matrix<Double> by lazy {
-                val cholesky =
-                    DecompositionFactory_DDRM.chol(rowNum, true).apply { decompose(origin.ddrm.copy()) }
-
-                EjmlMatrix(SimpleMatrix(cholesky.getT(null))) + LFeature
-            }
-        }
-
-        LupDecompositionFeature::class -> object : LupDecompositionFeature<Double> {
-            private val lup by lazy {
-                DecompositionFactory_DDRM.lu(origin.numRows(), origin.numCols()).apply { decompose(origin.ddrm.copy()) }
-            }
-
-            override val l: Matrix<Double> by lazy {
-                EjmlMatrix(SimpleMatrix(lup.getLower(null))) + LFeature
-            }
-
-            override val u: Matrix<Double> by lazy {
-                EjmlMatrix(SimpleMatrix(lup.getUpper(null))) + UFeature
-            }
-
-            override val p: Matrix<Double> by lazy { EjmlMatrix(SimpleMatrix(lup.getRowPivot(null))) }
-        }
-
-        else -> null
-    }?.let(type::cast)
-
     public override operator fun get(i: Int, j: Int): Double = origin[i, j]
 
     override fun equals(other: Any?): Boolean {
diff --git a/kmath-ejml/src/test/kotlin/space/kscience/kmath/ejml/EjmlMatrixTest.kt b/kmath-ejml/src/test/kotlin/space/kscience/kmath/ejml/EjmlMatrixTest.kt
index 7f31d2f93..70b2ce723 100644
--- a/kmath-ejml/src/test/kotlin/space/kscience/kmath/ejml/EjmlMatrixTest.kt
+++ b/kmath-ejml/src/test/kotlin/space/kscience/kmath/ejml/EjmlMatrixTest.kt
@@ -2,10 +2,7 @@ package space.kscience.kmath.ejml
 
 import org.ejml.dense.row.factory.DecompositionFactory_DDRM
 import org.ejml.simple.SimpleMatrix
-import space.kscience.kmath.linear.DeterminantFeature
-import space.kscience.kmath.linear.LupDecompositionFeature
-import space.kscience.kmath.linear.MatrixFeature
-import space.kscience.kmath.linear.plus
+import space.kscience.kmath.linear.*
 import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.nd.getFeature
 import kotlin.random.Random
@@ -45,9 +42,9 @@ internal class EjmlMatrixTest {
     fun features() {
         val m = randomMatrix
         val w = EjmlMatrix(m)
-        val det = w.getFeature<DeterminantFeature<Double>>() ?: fail()
+        val det: DeterminantFeature<Double> = EjmlLinearSpace.getFeature(w) ?: fail()
         assertEquals(m.determinant(), det.determinant)
-        val lup = w.getFeature<LupDecompositionFeature<Double>>() ?: fail()
+        val lup: LupDecompositionFeature<Double> = EjmlLinearSpace.getFeature(w) ?: fail()
 
         val ludecompositionF64 = DecompositionFactory_DDRM.lu(m.numRows(), m.numCols())
             .also { it.decompose(m.ddrm.copy()) }
-- 
2.34.1


From cceffa09e827bf0e17a2d79784d8927ce5653f6b Mon Sep 17 00:00:00 2001
From: Alexander Nozik <altavir@gmail.com>
Date: Mon, 15 Mar 2021 19:24:07 +0300
Subject: [PATCH 35/37] Bump dev version

---
 build.gradle.kts                                      |  2 +-
 .../space/kscience/kmath/commons/linear/CMMatrix.kt   | 11 ++++-------
 2 files changed, 5 insertions(+), 8 deletions(-)

diff --git a/build.gradle.kts b/build.gradle.kts
index 113107f69..9810e378f 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -20,7 +20,7 @@ allprojects {
     }
 
     group = "space.kscience"
-    version = "0.3.0"
+    version = "0.3.0-dev-2"
 }
 
 subprojects {
diff --git 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
index 5b45c2e51..4671598f7 100644
--- 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
@@ -103,7 +103,7 @@ public object CMLinearSpace : LinearSpace<Double, RealField> {
         structure.getFeature(type)?.let { return it }
 
         val origin = structure.toCM().origin
-        
+
         return when (type) {
             DiagonalFeature::class -> if (origin is DiagonalMatrix) DiagonalFeature else null
 
@@ -142,11 +142,8 @@ public object CMLinearSpace : LinearSpace<Double, RealField> {
     }
 }
 
-public operator fun CMMatrix.plus(other: CMMatrix): CMMatrix =
-    CMMatrix(origin.add(other.origin))
+public operator fun CMMatrix.plus(other: CMMatrix): CMMatrix = CMMatrix(origin.add(other.origin))
 
-public operator fun CMMatrix.minus(other: CMMatrix): CMMatrix =
-    CMMatrix(origin.subtract(other.origin))
+public operator fun CMMatrix.minus(other: CMMatrix): CMMatrix = CMMatrix(origin.subtract(other.origin))
 
-public infix fun CMMatrix.dot(other: CMMatrix): CMMatrix =
-    CMMatrix(origin.multiply(other.origin))
+public infix fun CMMatrix.dot(other: CMMatrix): CMMatrix = CMMatrix(origin.multiply(other.origin))
-- 
2.34.1


From 179a07e03432f4ded4e151ac384e8630705ee546 Mon Sep 17 00:00:00 2001
From: Alexander Nozik <altavir@gmail.com>
Date: Mon, 15 Mar 2021 19:41:37 +0300
Subject: [PATCH 36/37] Bump readme

---
 README.md                         | 7 ++++---
 docs/templates/README-TEMPLATE.md | 4 +---
 kmath-ast/README.md               | 6 +++---
 kmath-complex/README.md           | 6 +++---
 kmath-for-real/README.md          | 6 +++---
 kmath-functions/README.md         | 6 +++---
 kmath-nd4j/README.md              | 6 +++---
 7 files changed, 20 insertions(+), 21 deletions(-)

diff --git a/README.md b/README.md
index c95b0a13f..c129ba4ba 100644
--- a/README.md
+++ b/README.md
@@ -1,8 +1,9 @@
 [![JetBrains Research](https://jb.gg/badges/research.svg)](https://confluence.jetbrains.com/display/ALL/JetBrains+on+GitHub)
 [![DOI](https://zenodo.org/badge/129486382.svg)](https://zenodo.org/badge/latestdoi/129486382)
+
 ![Gradle build](https://github.com/mipt-npm/kmath/workflows/Gradle%20build/badge.svg)
 
-[![Kotlin JS IR supported](https://img.shields.io/badge/Kotlin%2FJS-IR%20supported-yellow)](https://kotl.in/jsirsupported)
+[![Maven Central](https://img.shields.io/maven-central/v/space.kscience/kmath-core.svg?label=Maven%20Central)](https://search.maven.org/search?q=g:%22space.kscience%22%20AND%20a:%22kmath-core%22)
 
 # KMath
 
@@ -253,8 +254,8 @@ repositories {
 }
 
 dependencies {
-    api("kscience.kmath:kmath-core:() -> kotlin.Any")
-    // api("kscience.kmath:kmath-core-jvm:() -> kotlin.Any") for jvm-specific version
+    api("kscience.kmath:kmath-core:0.3.0-dev-2")
+    // api("kscience.kmath:kmath-core-jvm:0.3.0-dev-2") for jvm-specific version
 }
 ```
 
diff --git a/docs/templates/README-TEMPLATE.md b/docs/templates/README-TEMPLATE.md
index 10bc7aab1..c8be0d300 100644
--- a/docs/templates/README-TEMPLATE.md
+++ b/docs/templates/README-TEMPLATE.md
@@ -3,9 +3,7 @@
 
 ![Gradle build](https://github.com/mipt-npm/kmath/workflows/Gradle%20build/badge.svg)
 
-Bintray:        [ ![Download](https://api.bintray.com/packages/mipt-npm/kscience/kmath-core/images/download.svg) ](https://bintray.com/mipt-npm/kscience/kmath-core/_latestVersion)
-
-Bintray-dev:    [ ![Download](https://api.bintray.com/packages/mipt-npm/dev/kmath-core/images/download.svg) ](https://bintray.com/mipt-npm/dev/kmath-core/_latestVersion)
+[![Maven Central](https://img.shields.io/maven-central/v/space.kscience/kmath-core.svg?label=Maven%20Central)](https://search.maven.org/search?q=g:%22space.kscience%22%20AND%20a:%22kmath-core%22)
 
 # KMath
 
diff --git a/kmath-ast/README.md b/kmath-ast/README.md
index e52f0fa96..a88b6f696 100644
--- a/kmath-ast/README.md
+++ b/kmath-ast/README.md
@@ -12,7 +12,7 @@ This subproject implements the following features:
 
 > #### Artifact:
 >
-> This module artifact: `space.kscience:kmath-ast:0.2.0`.
+> This module artifact: `space.kscience:kmath-ast:0.3.0-dev-2`.
 >
 > Bintray release version:        [ ![Download](https://api.bintray.com/packages/mipt-npm/kscience/kmath-ast/images/download.svg) ](https://bintray.com/mipt-npm/kscience/kmath-ast/_latestVersion)
 >
@@ -31,7 +31,7 @@ This subproject implements the following features:
 > }
 > 
 > dependencies {
->     implementation 'space.kscience:kmath-ast:0.2.0'
+>     implementation 'space.kscience:kmath-ast:0.3.0-dev-2'
 > }
 > ```
 > **Gradle Kotlin DSL:**
@@ -47,7 +47,7 @@ This subproject implements the following features:
 > }
 > 
 > dependencies {
->     implementation("space.kscience:kmath-ast:0.2.0")
+>     implementation("space.kscience:kmath-ast:0.3.0-dev-2")
 > }
 > ```
 
diff --git a/kmath-complex/README.md b/kmath-complex/README.md
index 71a75bd3e..7a7628a2c 100644
--- a/kmath-complex/README.md
+++ b/kmath-complex/README.md
@@ -8,7 +8,7 @@ Complex and hypercomplex number systems in KMath:
 
 > #### Artifact:
 >
-> This module artifact: `space.kscience:kmath-complex:0.2.0`.
+> This module artifact: `space.kscience:kmath-complex:0.3.0-dev-2`.
 >
 > Bintray release version:        [ ![Download](https://api.bintray.com/packages/mipt-npm/kscience/kmath-complex/images/download.svg) ](https://bintray.com/mipt-npm/kscience/kmath-complex/_latestVersion)
 >
@@ -27,7 +27,7 @@ Complex and hypercomplex number systems in KMath:
 > }
 > 
 > dependencies {
->     implementation 'space.kscience:kmath-complex:0.2.0'
+>     implementation 'space.kscience:kmath-complex:0.3.0-dev-2'
 > }
 > ```
 > **Gradle Kotlin DSL:**
@@ -43,6 +43,6 @@ Complex and hypercomplex number systems in KMath:
 > }
 > 
 > dependencies {
->     implementation("space.kscience:kmath-complex:0.2.0")
+>     implementation("space.kscience:kmath-complex:0.3.0-dev-2")
 > }
 > ```
diff --git a/kmath-for-real/README.md b/kmath-for-real/README.md
index 94b9eb59a..63c5cd249 100644
--- a/kmath-for-real/README.md
+++ b/kmath-for-real/README.md
@@ -7,7 +7,7 @@
 
 > #### Artifact:
 >
-> This module artifact: `space.kscience:kmath-for-real:0.2.0`.
+> This module artifact: `space.kscience:kmath-for-real:0.3.0-dev-2`.
 >
 > Bintray release version:        [ ![Download](https://api.bintray.com/packages/mipt-npm/kscience/kmath-for-real/images/download.svg) ](https://bintray.com/mipt-npm/kscience/kmath-for-real/_latestVersion)
 >
@@ -26,7 +26,7 @@
 > }
 > 
 > dependencies {
->     implementation 'space.kscience:kmath-for-real:0.2.0'
+>     implementation 'space.kscience:kmath-for-real:0.3.0-dev-2'
 > }
 > ```
 > **Gradle Kotlin DSL:**
@@ -42,6 +42,6 @@
 > }
 > 
 > dependencies {
->     implementation("space.kscience:kmath-for-real:0.2.0")
+>     implementation("space.kscience:kmath-for-real:0.3.0-dev-2")
 > }
 > ```
diff --git a/kmath-functions/README.md b/kmath-functions/README.md
index 0eae4e3c0..29cc68c8e 100644
--- a/kmath-functions/README.md
+++ b/kmath-functions/README.md
@@ -10,7 +10,7 @@ Functions and interpolations:
 
 > #### Artifact:
 >
-> This module artifact: `space.kscience:kmath-functions:0.2.0`.
+> This module artifact: `space.kscience:kmath-functions:0.3.0-dev-2`.
 >
 > Bintray release version:        [ ![Download](https://api.bintray.com/packages/mipt-npm/kscience/kmath-functions/images/download.svg) ](https://bintray.com/mipt-npm/kscience/kmath-functions/_latestVersion)
 >
@@ -29,7 +29,7 @@ Functions and interpolations:
 > }
 > 
 > dependencies {
->     implementation 'space.kscience:kmath-functions:0.2.0'
+>     implementation 'space.kscience:kmath-functions:0.3.0-dev-2'
 > }
 > ```
 > **Gradle Kotlin DSL:**
@@ -45,6 +45,6 @@ Functions and interpolations:
 > }
 > 
 > dependencies {
->     implementation("space.kscience:kmath-functions:0.2.0")
+>     implementation("space.kscience:kmath-functions:0.3.0-dev-2")
 > }
 > ```
diff --git a/kmath-nd4j/README.md b/kmath-nd4j/README.md
index 046c8127f..08f0ae541 100644
--- a/kmath-nd4j/README.md
+++ b/kmath-nd4j/README.md
@@ -9,7 +9,7 @@ This subproject implements the following features:
 
 > #### Artifact:
 >
-> This module artifact: `space.kscience:kmath-nd4j:0.2.0`.
+> This module artifact: `space.kscience:kmath-nd4j:0.3.0-dev-2`.
 >
 > Bintray release version:        [ ![Download](https://api.bintray.com/packages/mipt-npm/kscience/kmath-nd4j/images/download.svg) ](https://bintray.com/mipt-npm/kscience/kmath-nd4j/_latestVersion)
 >
@@ -28,7 +28,7 @@ This subproject implements the following features:
 > }
 > 
 > dependencies {
->     implementation 'space.kscience:kmath-nd4j:0.2.0'
+>     implementation 'space.kscience:kmath-nd4j:0.3.0-dev-2'
 > }
 > ```
 > **Gradle Kotlin DSL:**
@@ -44,7 +44,7 @@ This subproject implements the following features:
 > }
 > 
 > dependencies {
->     implementation("space.kscience:kmath-nd4j:0.2.0")
+>     implementation("space.kscience:kmath-nd4j:0.3.0-dev-2")
 > }
 > ```
 
-- 
2.34.1


From 17647742a8a5f1c7d99bf88b6905210ac7e75922 Mon Sep 17 00:00:00 2001
From: Alexander Nozik <altavir@gmail.com>
Date: Mon, 15 Mar 2021 19:45:46 +0300
Subject: [PATCH 37/37] Bump readme

---
 kmath-core/README.md | 55 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 55 insertions(+)
 create mode 100644 kmath-core/README.md

diff --git a/kmath-core/README.md b/kmath-core/README.md
new file mode 100644
index 000000000..14f1ecb41
--- /dev/null
+++ b/kmath-core/README.md
@@ -0,0 +1,55 @@
+# The Core Module (`kmath-core`)
+
+The core features of KMath:
+
+ - [algebras](src/commonMain/kotlin/kscience/kmath/operations/Algebra.kt) : Algebraic structures like rings, spaces and fields.
+ - [nd](src/commonMain/kotlin/kscience/kmath/structures/NDStructure.kt) : Many-dimensional structures and operations on them.
+ - [linear](src/commonMain/kotlin/kscience/kmath/operations/Algebra.kt) : Basic linear algebra operations (sums, products, etc.), backed by the `Space` API. Advanced linear algebra operations like matrix inversion and LU decomposition.
+ - [buffers](src/commonMain/kotlin/kscience/kmath/structures/Buffers.kt) : One-dimensional structure
+ - [expressions](src/commonMain/kotlin/kscience/kmath/expressions) : By writing a single mathematical expression once, users will be able to apply different types of 
+objects to the expression by providing a context. Expressions can be used for a wide variety of purposes from high 
+performance calculations to code generation.
+ - [domains](src/commonMain/kotlin/kscience/kmath/domains) : Domains
+ - [autodif](src/commonMain/kotlin/kscience/kmath/expressions/SimpleAutoDiff.kt) : Automatic differentiation
+
+
+> #### Artifact:
+>
+> This module artifact: `space.kscience:kmath-core:0.3.0-dev-2`.
+>
+> Bintray release version:        [ ![Download](https://api.bintray.com/packages/mipt-npm/kscience/kmath-core/images/download.svg) ](https://bintray.com/mipt-npm/kscience/kmath-core/_latestVersion)
+>
+> Bintray development version:    [ ![Download](https://api.bintray.com/packages/mipt-npm/dev/kmath-core/images/download.svg) ](https://bintray.com/mipt-npm/dev/kmath-core/_latestVersion)
+>
+> **Gradle:**
+>
+> ```gradle
+> repositories {
+>     maven { url 'https://repo.kotlin.link' }
+>     maven { url 'https://dl.bintray.com/hotkeytlt/maven' }
+>     maven { url "https://dl.bintray.com/kotlin/kotlin-eap" } // include for builds based on kotlin-eap
+>//     Uncomment if repo.kotlin.link is unavailable 
+>//     maven { url 'https://dl.bintray.com/mipt-npm/kscience' }
+>//     maven { url 'https://dl.bintray.com/mipt-npm/dev' }
+> }
+> 
+> dependencies {
+>     implementation 'space.kscience:kmath-core:0.3.0-dev-2'
+> }
+> ```
+> **Gradle Kotlin DSL:**
+>
+> ```kotlin
+> repositories {
+>     maven("https://repo.kotlin.link")
+>     maven("https://dl.bintray.com/kotlin/kotlin-eap") // include for builds based on kotlin-eap
+>     maven("https://dl.bintray.com/hotkeytlt/maven") // required for a
+>//     Uncomment if repo.kotlin.link is unavailable 
+>//     maven("https://dl.bintray.com/mipt-npm/kscience")
+>//     maven("https://dl.bintray.com/mipt-npm/dev")
+> }
+> 
+> dependencies {
+>     implementation("space.kscience:kmath-core:0.3.0-dev-2")
+> }
+> ```
-- 
2.34.1