.github/workflows/pages.yml

@@ -0,0 +1,40 @@
+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: Cache konan
+        uses: actions/cache@v2
+        with:
+          path: ~/.konan
+          key: ${{ runner.os }}-gradle-${{ hashFiles('*.gradle.kts') }}
+          restore-keys: |
+            ${{ runner.os }}-gradle-
+      - name: Build
+        run: |
+          ./gradlew dokkaHtmlMultiModule --no-daemon --no-parallel --stacktrace
+          mv build/dokka/htmlMultiModule/-modules.html build/dokka/htmlMultiModule/index.html
+      - name: Deploy to GitHub Pages
+        uses: JamesIves/github-pages-deploy-action@4.1.0
+        with:
+          branch: gh-pages
+          folder: build/dokka/htmlMultiModule

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
+- Buffer factories for primitives moved to MutableBuffer.Companion
 
 ### Deprecated
 

README.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
 
@@ -256,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("space.kscience:kmath-core:0.3.0-dev-2")
+    // api("kscience.kmath:kmath-core-jvm:0.3.0-dev-2") for jvm-specific version
 }
 ```
 

build.gradle.kts

@@ -20,7 +20,7 @@ allprojects {
     }
 
     group = "space.kscience"
-    version = "0.3.0"
+    version = "0.3.0-dev-2"
 }
 
 subprojects {

docs/templates/ARTIFACT-TEMPLATE.md

@@ -13,9 +13,6 @@
 >     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 {
@@ -29,9 +26,6 @@
 >     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 {

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
 
@@ -106,7 +104,7 @@ repositories {
 }
 
 dependencies {
-    api("kscience.kmath:kmath-core:$version")
+    api("${group}:kmath-core:$version")
     // api("kscience.kmath:kmath-core-jvm:$version") for jvm-specific version
 }
 ```

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 {

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

@@ -4,14 +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.linear.Matrix
-import space.kscience.kmath.linear.RealMatrixContext
+import space.kscience.kmath.commons.linear.CMLinearSpace
+import space.kscience.kmath.ejml.EjmlLinearSpace
+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,47 +18,47 @@ 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 = 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.run {
             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 {
+        LinearSpace.auto(RealField).invoke {
             blackhole.consume(matrix1 dot matrix2)
         }
     }
 
     @Benchmark
     fun realDot(blackhole: Blackhole) {
-        RealMatrixContext {
+        LinearSpace.real {
             blackhole.consume(matrix1 dot matrix2)
         }
     }

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)

examples/src/benchmarks/kotlin/space/kscience/kmath/benchmarks/MatrixInverseBenchmark.kt

@@ -4,44 +4,44 @@ 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.Matrix
-import space.kscience.kmath.linear.MatrixContext
+import space.kscience.kmath.linear.LinearSpace
 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
     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))
         }
     }

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))
     }
 }

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 = Point(0.0, 0.0, 0.0)
+    val sigma = Point(1.0, 1.0, 1.0)
+
+    val gaussian: (Point<Double>) -> Double = { x ->
+        require(x.size == x0.size)
+        kotlin.math.exp(-((x - x0) / sigma).square().sum())
+    }
+
+    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
+            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))
+
+}

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")

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() }

gradle.properties

@@ -1,10 +1,8 @@
 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.jvmargs=-XX:MaxMetaspaceSize=2G
 org.gradle.parallel=true
-
-kotlin.mpp.enableGranularSourceSetsMetadata=true
-kotlin.native.enableDependencyPropagation=false
-

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")
 > }
 > ```
 

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)

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

@@ -3,59 +3,28 @@ 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
 
-    @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 {
+        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) : Point<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)
@@ -63,16 +32,17 @@ public class CMVector(public val origin: RealVector) : Point<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 CMMatrixContext : MatrixContext<Double, CMMatrix> {
-    public override fun produce(rows: Int, columns: Int, initializer: (i: Int, j: Int) -> Double): CMMatrix {
-        val array = Array(rows) { i -> DoubleArray(columns) { j -> initializer(i, j) } }
+public object CMLinearSpace : LinearSpace<Double, RealField> {
+    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))
     }
 
@@ -82,40 +52,98 @@ public object CMMatrixContext : MatrixContext<Double, CMMatrix> {
         else -> {
             //TODO add feature analysis
             val array = Array(rowNum) { i -> DoubleArray(colNum) { j -> get(i, j) } }
-            CMMatrix(Array2DRowRealMatrix(array))
+            Array2DRowRealMatrix(array).wrap()
         }
     }
 
-    override fun scale(a: Matrix<Double>, value: Double): Matrix<Double> = a.toCM().times(value)
+    public fun Point<Double>.toCM(): CMVector = if (this is CMVector) this else {
+        val array = DoubleArray(size) { this[it] }
+        ArrayRealVector(array).wrap()
+    }
 
+    internal fun RealMatrix.wrap(): CMMatrix = CMMatrix(this)
+    internal fun RealVector.wrap(): CMVector = CMVector(this)
+
+    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 Point<Double>.plus(other: Point<Double>): CMVector =
+        toCM().origin.add(other.toCM().origin).wrap()
+
+    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 =
-        CMMatrix(toCM().origin.multiply(other.toCM().origin))
+        toCM().origin.multiply(other.toCM().origin).wrap()
 
     public override fun Matrix<Double>.dot(vector: Point<Double>): CMVector =
-        CMVector(toCM().origin.preMultiply(vector.toCM().origin))
+        toCM().origin.preMultiply(vector.toCM().origin).wrap()
 
-    public override operator fun Matrix<Double>.unaryMinus(): CMMatrix =
-        produce(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 =
-        produce(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 Point<Double>.times(value: Double): CMVector =
+        toCM().origin.mapMultiply(value).wrap()
+
+    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 =
-    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))

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()
+): CMMatrix = solver(a, decomposition).solve(b.toCM().origin).wrap()
 
-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()
+): CMMatrix = solver(a, decomposition).inverse.wrap()

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")
 > }
 > ```

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")
+> }
+> ```

kmath-core/api/kmath-core.api

@@ -432,106 +432,23 @@ 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 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 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 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 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 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 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 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 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 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 {
@@ -549,37 +466,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;
 }
@@ -588,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 asPoint (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;
@@ -603,9 +484,58 @@ 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;
+	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 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/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/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 +552,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 {
@@ -688,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;
@@ -701,12 +601,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 +617,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 +637,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;
@@ -826,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
 }
@@ -882,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 {
@@ -1147,10 +965,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
 }
 
@@ -1307,22 +1125,21 @@ 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
 }
 
 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 {
 	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
 }
 
@@ -2298,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 {
@@ -2306,13 +2122,16 @@ 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;
 }
 
@@ -2376,7 +2195,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 +2231,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 +2289,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 {
@@ -2498,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 {
@@ -2749,7 +2572,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 +2608,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 {

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].
      */

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)
 }
 

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>> {

kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/BufferMatrix.kt

@@ -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)"
-    }
-
-
-}

kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/BufferedLinearSpace.kt

@@ -0,0 +1,83 @@
+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 BufferedLinearSpace<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): Point<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::minus. 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() }
+            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: 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() }
+            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()
+    }
+}

kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSolver.kt

@@ -1,25 +1,33 @@
 package space.kscience.kmath.linear
 
-import space.kscience.kmath.structures.Buffer
-import space.kscience.kmath.structures.VirtualBuffer
-
-public typealias Point<T> = Buffer<T>
+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>
-    public fun solve(a: Matrix<T>, b: Point<T>): Point<T> = solve(a, b.asMatrix()).asPoint()
-    public fun inverse(a: 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()
+
+    /**
+     * Get inverse of a matrix
+     */
+    public fun inverse(matrix: 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(): Point<T> =
     if (this.colNum == 1)
-        VirtualBuffer(rowNum) { get(it, 0) }
+        as1D()
     else
         error("Can't convert matrix with more than one column to vector")
 

kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpace.kt

@@ -0,0 +1,202 @@
+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 space.kscience.kmath.structures.RealBuffer
+import kotlin.reflect.KClass
+
+/**
+ * Alias for [Structure2D] with more familiar name.
+ *
+ * @param T the type of items.
+ */
+public typealias Matrix<T> = Structure2D<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].
+ *
+ * @param T the type of items in the matrices.
+ * @param M the type of operated matrices.
+ */
+public interface LinearSpace<T : Any, out 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): Point<T>
+
+    public operator fun Matrix<T>.unaryMinus(): Matrix<T> = buildMatrix(rowNum, colNum) { i, j ->
+        -get(i, j)
+    }
+
+    public operator fun Point<T>.unaryMinus(): Point<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 Point<T>.plus(other: Point<T>): Point<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 Point<T>.minus(other: Point<T>): Point<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: Point<T>): Point<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 Point<T>.times(value: T): Point<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: Point<T>): Point<T> = v * this
+
+    /**
+     * 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: Matrix<T>, type: KClass<F>): F? = structure.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> = BufferedLinearSpace(algebra, bufferFactory)
+
+        public val real: LinearSpace<Double, RealField> = buffered(RealField, ::RealBuffer)
+
+        /**
+         * 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)
+    }
+}
+
+/**
+ * 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> 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)
+

kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LupDecomposition.kt

@@ -3,16 +3,16 @@ 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].
  */
 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(::RealBuffer, 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 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, RealField, a) { it < 1e-11 }
+    val bufferFactory: MutableBufferFactory<Double> = ::RealBuffer
+    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 LinearSpace<Double, RealField>.inverseWithLup(matrix: Matrix<Double>): Matrix<Double> =
     solveWithLup(matrix, one(matrix.rowNum, matrix.colNum))

kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixBuilder.kt

@@ -1,46 +1,43 @@
 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> {
+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" }
-        val buffer = elements.asBuffer()
-        return BufferMatrix(rows, columns, buffer)
+        return linearSpace.buildMatrix(rows, columns) { i, j -> elements[i * columns + j] }
     }
 
     //TODO add specific matrix builder functions like diagonal, etc
 }
 
-public fun Structure2D.Companion.build(rows: Int, columns: Int): MatrixBuilder = MatrixBuilder(rows, columns)
+/**
+ * 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)
 
-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): Point<T> {
+    return buildVector(elements.size) { elements[it] }
 }
 
-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)

kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixContext.kt

@@ -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 } }
-}

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

kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/RealMatrixContext.kt

@@ -1,85 +0,0 @@
-package space.kscience.kmath.linear
-
-import space.kscience.kmath.operations.ScaleOperations
-import space.kscience.kmath.structures.RealBuffer
-
-public object RealMatrixContext : MatrixContext<Double, BufferMatrix<Double>>, ScaleOperations<Matrix<Double>> {
-
-    public override fun produce(
-        rows: Int,
-        columns: Int,
-        initializer: (i: Int, j: Int) -> Double,
-    ): BufferMatrix<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 {
-        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
-
-    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()
-        val otherBufferMatrix = other.toBufferMatrix()
-        return produce(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 produce(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 }
-    }
-
-    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 MatrixContext.Companion.real: RealMatrixContext get() = RealMatrixContext

kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/VectorSpace.kt

@@ -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) }
-}

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.
  *
@@ -8,7 +10,7 @@ package space.kscience.kmath.linear
 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)
@@ -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 {
@@ -31,6 +29,4 @@ public class VirtualMatrix<T : Any>(
         result = 31 * result + generator.hashCode()
         return result
     }
-
-
 }

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

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.
@@ -19,7 +21,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.
      */
@@ -56,20 +58,44 @@ 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.
  *
  * @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 +103,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
 }

kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/NDStructure.kt

@@ -48,11 +48,11 @@ 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 <T : Any> getFeature(type: KClass<T>): T? = null
+    public fun <F : Any> getFeature(type: KClass<F>): F? = null
 
     public companion object {
         /**
@@ -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,

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>> {

kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/Structure1D.kt

@@ -45,12 +45,23 @@ 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)
-} else
-    error("Can't create 1d-structure from ${shape.size}d-structure")
+public fun <T> NDStructure<T>.as1D(): Structure1D<T> = this as? Structure1D<T> ?: if (shape.size == 1) {
+    when (this) {
+        is NDBuffer -> Buffer1DWrapper(this.buffer)
+        else -> Structure1DWrapper(this)
+    }
+} else error("Can't create 1d-structure from ${shape.size}d-structure")
 
 /**
  * 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
+}

kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/Structure2D.kt

@@ -1,9 +1,9 @@
 package space.kscience.kmath.nd
 
-import space.kscience.kmath.linear.BufferMatrix
-import space.kscience.kmath.linear.RealMatrixContext
+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.
@@ -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.
@@ -54,21 +54,13 @@ 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
 }
 
 /**
  * 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]
@@ -76,20 +68,27 @@ 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()
 }
 
 /**
  * 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.
+ * Expose inner [NDStructure] if possible
  */
-public typealias Matrix<T> = Structure2D<T>
+internal fun <T> Structure2D<T>.unwrap(): NDStructure<T> =
+    if (this is Structure2DWrapper) structure
+    else this

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.

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

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,21 +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)
-
-/**
- * Converts this [Buffer] to a new [List]
- */
-public fun <T> Buffer<T>.toList(): List<T> = asSequence().toList()
-
 /**
  * Returns an [IntRange] of the valid indices for this [Buffer].
  */
@@ -126,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
          */
@@ -141,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)
             }
 
@@ -158,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) }
     }
 }
 
@@ -187,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].
  *
@@ -216,16 +214,20 @@ 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].
  *
  * @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
+    override val size: Int get() = array.size
 
     override operator fun get(index: Int): T = array[index]
 
@@ -243,16 +245,6 @@ public class ArrayBuffer<T>(private 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].
  *
@@ -293,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

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> =
@@ -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) ->

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.

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.

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.

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) }
         }

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.

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.

kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/bufferOperation.kt

@@ -0,0 +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)) }
+
+/**
+ * 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]) }
+}

kmath-core/src/commonTest/kotlin/space/kscience/kmath/linear/MatrixTest.kt

@@ -1,23 +1,24 @@
 package space.kscience.kmath.linear
 
+import space.kscience.kmath.misc.UnstableKMathAPI
 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
 
+@UnstableKMathAPI
 @Suppress("UNUSED_VARIABLE")
 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)
     }
 
     @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
         )
@@ -39,7 +40,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 = LinearSpace.real.run { res dot this@pow }
             }
             return res
         }
@@ -52,7 +53,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

kmath-core/src/commonTest/kotlin/space/kscience/kmath/linear/RealLUSolverTest.kt

@@ -1,29 +1,31 @@
 package space.kscience.kmath.linear
 
+import space.kscience.kmath.misc.UnstableKMathAPI
 import kotlin.test.Test
 import kotlin.test.assertEquals
 
+@UnstableKMathAPI
 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)
     }
 
     @Test
     fun testDecomposition() {
-        val matrix = Matrix.square(
-            3.0, 1.0,
-            1.0, 3.0
-        )
+        LinearSpace.real.run {
+            val matrix = matrix(2, 2)(
+                3.0, 1.0,
+                2.0, 3.0
+            )
 
-        MatrixContext.real.run {
             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)
         }
@@ -31,14 +33,14 @@ class RealLUSolverTest {
 
     @Test
     fun testInvert() {
-        val matrix = Matrix.square(
+        val matrix = LinearSpace.real.matrix(2, 2)(
             3.0, 1.0,
             1.0, 3.0
         )
 
-        val inverted = MatrixContext.real.inverseWithLup(matrix)
+        val inverted = LinearSpace.real.inverseWithLup(matrix)
 
-        val expected = Matrix.square(
+        val expected = LinearSpace.real.matrix(2, 2)(
             0.375, -0.125,
             -0.125, 0.375
         )

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
@@ -10,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() }
 
@@ -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) {

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: MatrixContext<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,17 +94,19 @@ public inline class DMatrixContext<T : Any>(public val context: MatrixContext<T,
     /**
      * 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.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> {
+    public inline fun <reified D : Dimension> point(noinline initializer: A.(Int) -> T): DPoint<T, D> {
         val size = Dimension.dim<D>()
 
         return DPoint.coerceUnsafe(
-            context.point(
+            context.buildVector(
                 size.toInt(),
                 initializer
             )
@@ -112,31 +115,31 @@ public inline class DMatrixContext<T : Any>(public val context: MatrixContext<T,
 
     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(MatrixContext.real)
+        public val real: DMatrixContext<Double, RealField> = DMatrixContext(LinearSpace.real)
     }
 }
 
@@ -144,11 +147,11 @@ public inline class DMatrixContext<T : Any>(public val context: MatrixContext<T,
 /**
  * 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
     }

kmath-ejml/src/main/kotlin/space/kscience/kmath/ejml/EjmlLinearSpace.kt

@@ -0,0 +1,187 @@
+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].
+ *
+ * @author Iaroslav Postovalov
+ */
+public object EjmlLinearSpace : LinearSpace<Double, RealField> {
+
+    override val elementAlgebra: RealField get() = RealField
+
+    /**
+     * Converts this matrix to EJML one.
+     */
+    @OptIn(UnstableKMathAPI::class)
+    public fun Matrix<Double>.toEjml(): EjmlMatrix = when (val matrix = origin) {
+        is EjmlMatrix -> matrix
+        else -> buildMatrix(rowNum, colNum) { i, j -> get(i, j) }
+    }
+
+    /**
+     * Converts this vector to EJML one.
+     */
+    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) }
+        })
+    }
+
+    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] = RealField.initializer(row, col) }
+            }
+        })
+
+    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) }
+        })
+
+    private fun SimpleMatrix.wrapMatrix() = EjmlMatrix(this)
+    private fun SimpleMatrix.wrapVector() = EjmlVector(this)
+
+    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))
+
+    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 =
+        (toEjml().origin - other.toEjml().origin).wrapMatrix()
+
+    public override operator fun Matrix<Double>.times(value: Double): EjmlMatrix =
+        toEjml().origin.scale(value).wrapMatrix()
+
+    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 Point<Double>.plus(other: Point<Double>): EjmlVector =
+        (toEjml().origin + other.toEjml().origin).wrapVector()
+
+    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 Point<Double>.times(value: Double): EjmlVector =
+        toEjml().origin.scale(value).wrapVector()
+
+    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)
+    }
+}
+
+/**
+ * Solves for X in the following equation: x = a^-1*b, where 'a' is base matrix and 'b' is an n by p matrix.
+ *
+ * @param a the base matrix.
+ * @param b n by p matrix.
+ * @return the solution for 'x' that is n by p.
+ * @author Iaroslav Postovalov
+ */
+public fun EjmlLinearSpace.solve(a: Matrix<Double>, b: Matrix<Double>): EjmlMatrix =
+    EjmlMatrix(a.toEjml().origin.solve(b.toEjml().origin))
+
+/**
+ * Solves for X in the following equation: x = a^(-1)*b, where 'a' is base matrix and 'b' is an n by p matrix.
+ *
+ * @param a the base matrix.
+ * @param b n by p vector.
+ * @return the solution for 'x' that is n by p.
+ * @author Iaroslav Postovalov
+ */
+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 EjmlLinearSpace.inverse(matrix: Matrix<Double>): Matrix<Double> = matrix.toEjml().inverted()

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,73 +14,11 @@ 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 {
         if (this === other) return true
-        if (other !is Matrix<*>) return false
+        if (other !is NDStructure<*>) return false
         return NDStructure.contentEquals(this, other)
     }
 

kmath-ejml/src/main/kotlin/space/kscience/kmath/ejml/EjmlMatrixContext.kt

@@ -1,92 +0,0 @@
-package space.kscience.kmath.ejml
-
-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>, ScaleOperations<Matrix<Double>> {
-
-    /**
-     * Converts this matrix to EJML one.
-     */
-    @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) }
-    }
-
-    /**
-     * Converts this vector to EJML one.
-     */
-    public fun Point<Double>.toEjml(): EjmlVector =
-        if (this is EjmlVector) this else EjmlVector(SimpleMatrix(size, 1).also {
-            (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 =
-        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> =
-        EjmlVector(SimpleMatrix(size, 1).also {
-            (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))
-
-    public override fun Matrix<Double>.dot(vector: Point<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 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))
-}
-
-/**
- * Solves for X in the following equation: x = a^-1*b, where 'a' is base matrix and 'b' is an n by p matrix.
- *
- * @param a the base matrix.
- * @param b n by p matrix.
- * @return the solution for 'x' that is n by p.
- * @author Iaroslav Postovalov
- */
-public fun EjmlMatrixContext.solve(a: Matrix<Double>, b: Matrix<Double>): EjmlMatrix =
-    EjmlMatrix(a.toEjml().origin.solve(b.toEjml().origin))
-
-/**
- * Solves for X in the following equation: x = a^(-1)*b, where 'a' is base matrix and 'b' is an n by p matrix.
- *
- * @param a the base matrix.
- * @param b n by p vector.
- * @return the solution for 'x' that is n by p.
- * @author Iaroslav Postovalov
- */
-public fun EjmlMatrixContext.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()

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()) }

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")
 > }
 > ```

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,15 +22,19 @@ 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)
+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 MatrixContext.real.produce(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 {
-    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,38 +47,38 @@ public fun RealMatrix.repeatStackVertical(n: Int): RealMatrix =
  */
 
 public operator fun RealMatrix.times(double: Double): RealMatrix =
-    MatrixContext.real.produce(rowNum, colNum) { row, col ->
-        this[row, col] * double
+    LinearSpace.real.buildMatrix(rowNum, colNum) { row, col ->
+        get(row, col) * double
     }
 
 public operator fun RealMatrix.plus(double: Double): RealMatrix =
-    MatrixContext.real.produce(rowNum, colNum) { row, col ->
-        this[row, col] + double
+    LinearSpace.real.buildMatrix(rowNum, colNum) { row, col ->
+        get(row, col) + double
     }
 
 public operator fun RealMatrix.minus(double: Double): RealMatrix =
-    MatrixContext.real.produce(rowNum, colNum) { row, col ->
-        this[row, col] - double
+    LinearSpace.real.buildMatrix(rowNum, colNum) { row, col ->
+        get(row, col) - double
     }
 
 public operator fun RealMatrix.div(double: Double): RealMatrix =
-    MatrixContext.real.produce(rowNum, colNum) { row, col ->
-        this[row, col] / double
+    LinearSpace.real.buildMatrix(rowNum, colNum) { row, col ->
+        get(row, col) / double
     }
 
 public operator fun Double.times(matrix: RealMatrix): RealMatrix =
-    MatrixContext.real.produce(matrix.rowNum, matrix.colNum) { row, col ->
-        this * matrix[row, col]
+    LinearSpace.real.buildMatrix(matrix.rowNum, matrix.colNum) { row, col ->
+        this@times * matrix[row, col]
     }
 
 public operator fun Double.plus(matrix: RealMatrix): RealMatrix =
-    MatrixContext.real.produce(matrix.rowNum, matrix.colNum) { row, col ->
-        this + matrix[row, col]
+    LinearSpace.real.buildMatrix(matrix.rowNum, matrix.colNum) { row, col ->
+        this@plus + matrix[row, col]
     }
 
 public operator fun Double.minus(matrix: RealMatrix): RealMatrix =
-    MatrixContext.real.produce(matrix.rowNum, matrix.colNum) { row, col ->
-        this - matrix[row, col]
+    LinearSpace.real.buildMatrix(matrix.rowNum, matrix.colNum) { row, col ->
+        this@minus - matrix[row, col]
     }
 
 // TODO: does this operation make sense? Should it be 'this/matrix[row, col]'?
@@ -87,29 +92,29 @@ 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@times[row, col] * other[row, col] }
 
 public operator fun RealMatrix.plus(other: RealMatrix): RealMatrix =
-    MatrixContext.real.add(this, other)
+    LinearSpace.real.run { this@plus + 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@minus[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]
+            get(row, col)
         else
             mapper(rows[row])
     }
 
 public fun RealMatrix.extractColumns(columnRange: IntRange): RealMatrix =
-    MatrixContext.real.produce(rowNum, columnRange.count()) { row, col ->
-        this[row, columnRange.first + col]
+    LinearSpace.real.buildMatrix(rowNum, columnRange.count()) { row, col ->
+        this@extractColumns[row, columnRange.first + col]
     }
 
 public fun RealMatrix.extractColumn(columnIndex: Int): RealMatrix =
@@ -141,14 +146,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
 

kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/RealVector.kt

@@ -1,10 +1,13 @@
 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
 import kotlin.math.pow
 import kotlin.math.sqrt
 
@@ -19,18 +22,19 @@ 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"}
+    require(size == other.size) { "Vector size $size expected but ${other.size} found" }
     return mapIndexed { index, value -> value + other[index] }
 }
 
@@ -41,7 +45,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 +54,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 +63,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 +92,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
+}

kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/dot.kt

@@ -1,31 +1,12 @@
 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.linear.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
 }

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
@@ -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 = Matrix.build(2, 3)(
+        val matrix1 = realMatrix(2, 3)(
             1.0, 0.0, 0.0,
             0.0, 1.0, 2.0
         )
-        val matrix2 = Matrix.build(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,12 +48,12 @@ internal class RealMatrixTest {
 
     @Test
     fun testMatrixAndDouble() {
-        val matrix1 = Matrix.build(2, 3)(
+        val matrix1 = realMatrix(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 +62,13 @@ internal class RealMatrixTest {
 
     @Test
     fun testDoubleAndMatrix() {
-        val matrix1 = Matrix.build(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 = Matrix.build(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 = Matrix.build(2, 3)(
+        val matrix1 = realMatrix(2, 3)(
             -1.0, 0.0, 3.0,
             4.0, -6.0, -2.0
         )
-        val matrix2 = Matrix.build(2, 3)(
+        val matrix2 = realMatrix(2, 3)(
             1.0, 0.0, 9.0,
             16.0, 36.0, 4.0
         )
-        val matrix3 = Matrix.build(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 = Matrix.build(2, 3)(
+        val matrix1 = realMatrix(2, 3)(
             -1.0, 0.0, 3.0,
             4.0, -6.0, 7.0
         )
-        val matrix2 = Matrix.build(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 = Matrix.build(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 = Matrix.build(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 = Matrix.build(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 = Matrix.build(2, 1)(0.0, -6.0)
-        val cols1to2 = Matrix.build(2, 2)(
+        val col1 = realMatrix(2, 1)(0.0, -6.0)
+        val cols1to2 = realMatrix(2, 2)(
             0.0, 3.0,
             -6.0, 7.0
         )
@@ -147,7 +148,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
         )

kmath-for-real/src/commonTest/kotlin/kaceince/kmath/real/RealVectorTest.kt

@@ -1,38 +1,36 @@
 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
-import space.kscience.kmath.operations.invoke
 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 = MatrixContext.real { matrix1 dot matrix2 }
+        val product = LinearSpace.real.run { matrix1 dot matrix2 }
         assertEquals(5.0, product[1, 0])
         assertEquals(6.0, product[2, 2])
     }

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")
 > }
 > ```

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()))

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")
 > }
 > ```
 

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)