161 changed files with 1143 additions and 1470 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -201,7 +201,7 @@
 - Full autodiff refactoring based on `Symbol`
 - `kmath-prob` renamed to `kmath-stat`
 - Grid generators moved to `kmath-for-real`
- Use `Point<Float64>` instead of specialized type in `kmath-for-real`
+- Use `Point<Double>` instead of specialized type in `kmath-for-real`
 - Optimized dot product for buffer matrices moved to `kmath-for-real`
 - EjmlMatrix context is an object
 - Matrix LUP `inverse` renamed to `inverseWithLup`
--- a/benchmarks/README.md
+++ b/benchmarks/README.md
@ -1,119 +1,4 @@
-# BenchmarksResult
-
-## Report for benchmark configuration <code>main</code>
-
-* Run on Java HotSpot(TM) 64-Bit Server VM (build 21.0.4+8-LTS-jvmci-23.1-b41) with Java process:
-
-```
-C:\Users\altavir\scoop\apps\graalvm-oracle-21jdk\current\bin\java.exe -XX:ThreadPriorityPolicy=1 -XX:+UnlockExperimentalVMOptions -XX:+EnableJVMCIProduct -XX:-UnlockExperimentalVMOptions -Dfile.encoding=UTF-8 -Duser.country=US -Duser.language=en -Duser.variant
-```
-* JMH 1.21 was used in `thrpt` mode with 5 warmup iterations by 10 s and 5 measurement iterations by 10 s.
-### [ArrayBenchmark](src/jvmMain/kotlin/space/kscience/kmath/benchmarks/ArrayBenchmark.kt)
-
-| Benchmark | Score |
-|:---------:|:-----:|
-|`benchmarkArrayRead`|1.9E+07 &plusmn; 2.3E+05 ops/s|
-|`benchmarkBufferRead`|1.4E+07 &plusmn; 8.7E+05 ops/s|
-|`nativeBufferRead`|1.4E+07 &plusmn; 1.3E+06 ops/s|
-### [BigIntBenchmark](src/jvmMain/kotlin/space/kscience/kmath/benchmarks/BigIntBenchmark.kt)
-
-| Benchmark | Score |
-|:---------:|:-----:|
-|`jvmAdd`|5.1E+07 &plusmn; 1.3E+06 ops/s|
-|`jvmAddLarge`|5.1E+04 &plusmn; 8.2E+02 ops/s|
-|`jvmMultiply`|8.5E+07 &plusmn; 9.7E+06 ops/s|
-|`jvmMultiplyLarge`|2.5E+02 &plusmn; 15 ops/s|
-|`jvmParsing10`|8.7E+06 &plusmn; 5.1E+05 ops/s|
-|`jvmParsing16`|6.4E+06 &plusmn; 1.8E+05 ops/s|
-|`jvmPower`|28 &plusmn; 0.79 ops/s|
-|`jvmSmallAdd`|7.0E+07 &plusmn; 4.3E+06 ops/s|
-|`kmAdd`|4.8E+07 &plusmn; 2.2E+06 ops/s|
-|`kmAddLarge`|3.5E+04 &plusmn; 3.7E+03 ops/s|
-|`kmMultiply`|6.7E+07 &plusmn; 1.5E+07 ops/s|
-|`kmMultiplyLarge`|54 &plusmn; 4.2 ops/s|
-|`kmParsing10`|4.5E+06 &plusmn; 8.3E+04 ops/s|
-|`kmParsing16`|4.9E+06 &plusmn; 1.1E+05 ops/s|
-|`kmPower`|10 &plusmn; 0.96 ops/s|
-|`kmSmallAdd`|4.1E+07 &plusmn; 5.9E+05 ops/s|
-### [BufferBenchmark](src/jvmMain/kotlin/space/kscience/kmath/benchmarks/BufferBenchmark.kt)
-
-| Benchmark | Score |
-|:---------:|:-----:|
-|`bufferViewReadWrite`|5.8E+06 &plusmn; 1.6E+05 ops/s|
-|`bufferViewReadWriteSpecialized`|5.6E+06 &plusmn; 2.6E+05 ops/s|
-|`complexBufferReadWrite`|6.6E+06 &plusmn; 2.7E+05 ops/s|
-|`doubleArrayReadWrite`|7.5E+06 &plusmn; 1.0E+06 ops/s|
-|`doubleBufferReadWrite`|8.0E+06 &plusmn; 6.7E+05 ops/s|
-### [DotBenchmark](src/jvmMain/kotlin/space/kscience/kmath/benchmarks/DotBenchmark.kt)
-
-| Benchmark | Score |
-|:---------:|:-----:|
-|`bufferedDot`|1.3 &plusmn; 0.020 ops/s|
-|`cmDot`|0.47 &plusmn; 0.42 ops/s|
-|`cmDotWithConversion`|0.76 &plusmn; 0.13 ops/s|
-|`ejmlDot`|6.7 &plusmn; 0.091 ops/s|
-|`ejmlDotWithConversion`|6.4 &plusmn; 0.82 ops/s|
-|`multikDot`|40 &plusmn; 6.7 ops/s|
-|`parallelDot`|12 &plusmn; 1.8 ops/s|
-|`tensorDot`|1.2 &plusmn; 0.041 ops/s|
-|`tfDot`|5.9 &plusmn; 0.49 ops/s|
-### [ExpressionsInterpretersBenchmark](src/jvmMain/kotlin/space/kscience/kmath/benchmarks/ExpressionsInterpretersBenchmark.kt)
-
-| Benchmark | Score |
-|:---------:|:-----:|
-|`asmGenericExpression`|29 &plusmn; 1.2 ops/s|
-|`asmPrimitiveExpression`|43 &plusmn; 1.3 ops/s|
-|`asmPrimitiveExpressionArray`|71 &plusmn; 0.38 ops/s|
-|`functionalExpression`|5.6 &plusmn; 0.11 ops/s|
-|`justCalculate`|69 &plusmn; 9.0 ops/s|
-|`mstExpression`|7.1 &plusmn; 0.020 ops/s|
-|`rawExpression`|41 &plusmn; 1.5 ops/s|
-### [IntegrationBenchmark](src/jvmMain/kotlin/space/kscience/kmath/benchmarks/IntegrationBenchmark.kt)
-
-| Benchmark | Score |
-|:---------:|:-----:|
-|`complexIntegration`|3.6E+03 &plusmn; 1.9E+02 ops/s|
-|`doubleIntegration`|3.7E+03 &plusmn; 12 ops/s|
-### [JafamaBenchmark](src/jvmMain/kotlin/space/kscience/kmath/benchmarks/JafamaBenchmark.kt)
-
-| Benchmark | Score |
-|:---------:|:-----:|
-|`core`|38 &plusmn; 0.64 ops/s|
-|`jafama`|52 &plusmn; 0.36 ops/s|
-|`strictJafama`|52 &plusmn; 4.0 ops/s|
-### [MatrixInverseBenchmark](src/jvmMain/kotlin/space/kscience/kmath/benchmarks/MatrixInverseBenchmark.kt)
-
-| Benchmark | Score |
-|:---------:|:-----:|
-|`cmLUPInversion`|2.2E+03 &plusmn; 76 ops/s|
-|`ejmlInverse`|1.3E+03 &plusmn; 5.7 ops/s|
-|`kmathLupInversion`|9.5E+02 &plusmn; 1.8E+02 ops/s|
-|`kmathParallelLupInversion`|9.1E+02 &plusmn; 1.4E+02 ops/s|
-### [NDFieldBenchmark](src/jvmMain/kotlin/space/kscience/kmath/benchmarks/NDFieldBenchmark.kt)
-
-| Benchmark | Score |
-|:---------:|:-----:|
-|`boxingFieldAdd`|7.7 &plusmn; 0.79 ops/s|
-|`multikAdd`|6.5 &plusmn; 0.33 ops/s|
-|`multikInPlaceAdd`|64 &plusmn; 0.79 ops/s|
-|`specializedFieldAdd`|8.0 &plusmn; 0.090 ops/s|
-|`tensorAdd`|9.2 &plusmn; 0.053 ops/s|
-|`tensorInPlaceAdd`|17 &plusmn; 10 ops/s|
-|`viktorAdd`|7.6 &plusmn; 1.2 ops/s|
-### [ViktorBenchmark](src/jvmMain/kotlin/space/kscience/kmath/benchmarks/ViktorBenchmark.kt)
-
-| Benchmark | Score |
-|:---------:|:-----:|
-|`doubleFieldAddition`|7.7 &plusmn; 0.34 ops/s|
-|`rawViktor`|5.9 &plusmn; 1.1 ops/s|
-|`viktorFieldAddition`|7.3 &plusmn; 1.1 ops/s|
-### [ViktorLogBenchmark](src/jvmMain/kotlin/space/kscience/kmath/benchmarks/ViktorLogBenchmark.kt)
-
-| Benchmark | Score |
-|:---------:|:-----:|
-|`rawViktorLog`|1.4 &plusmn; 0.076 ops/s|
-|`realFieldLog`|1.3 &plusmn; 0.069 ops/s|
-|`viktorFieldLog`|1.3 &plusmn; 0.032 ops/s|
+# Module benchmarks



--- a/benchmarks/build.gradle.kts
+++ b/benchmarks/build.gradle.kts
@ -1,14 +1,11 @@
-import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
-import com.fasterxml.jackson.module.kotlin.readValue
-import kotlinx.benchmark.gradle.BenchmarksExtension
-import java.time.LocalDateTime
-import java.time.ZoneId
-import java.util.*
+@file:Suppress("UNUSED_VARIABLE")
+
+import space.kscience.kmath.benchmarks.addBenchmarkProperties

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

 allOpen.annotation("org.openjdk.jmh.annotations.State")
@ -161,121 +158,8 @@ kotlin {
    }
 }

-
-private data class JmhReport(
-    val jmhVersion: String,
-    val benchmark: String,
-    val mode: String,
-    val threads: Int,
-    val forks: Int,
-    val jvm: String,
-    val jvmArgs: List<String>,
-    val jdkVersion: String,
-    val vmName: String,
-    val vmVersion: String,
-    val warmupIterations: Int,
-    val warmupTime: String,
-    val warmupBatchSize: Int,
-    val measurementIterations: Int,
-    val measurementTime: String,
-    val measurementBatchSize: Int,
-    val params: Map<String, String> = emptyMap(),
-    val primaryMetric: PrimaryMetric,
-    val secondaryMetrics: Map<String, SecondaryMetric>,
-) {
-    interface Metric {
-        val score: Double
-        val scoreError: Double
-        val scoreConfidence: List<Double>
-        val scorePercentiles: Map<Double, Double>
-        val scoreUnit: String
-    }
-
-    data class PrimaryMetric(
-        override val score: Double,
-        override val scoreError: Double,
-        override val scoreConfidence: List<Double>,
-        override val scorePercentiles: Map<Double, Double>,
-        override val scoreUnit: String,
-        val rawDataHistogram: List<List<List<List<Double>>>>? = null,
-        val rawData: List<List<Double>>? = null,
-    ) : Metric
-
-    data class SecondaryMetric(
-        override val score: Double,
-        override val scoreError: Double,
-        override val scoreConfidence: List<Double>,
-        override val scorePercentiles: Map<Double, Double>,
-        override val scoreUnit: String,
-        val rawData: List<List<Double>>,
-    ) : Metric
-}
-
 readme {
    maturity = space.kscience.gradle.Maturity.EXPERIMENTAL
-
-    val jsonMapper = jacksonObjectMapper()
-
-    fun noun(number: Number, singular: String, plural: String) = if (number.toLong() == 1L) singular else plural
-
-    extensions.findByType(BenchmarksExtension::class.java)?.configurations?.forEach { cfg ->
-        val propertyName =
-            "benchmark${cfg.name.replaceFirstChar { if (it.isLowerCase()) it.titlecase(Locale.getDefault()) else it.toString() }}"
-
-        logger.info("Processing benchmark data from benchmark ${cfg.name} into readme property $propertyName")
-
-        val launches = layout.buildDirectory.dir("reports/benchmarks/${cfg.name}").get().asFile
-        if (!launches.exists()) return@forEach
-
-        property(propertyName) {
-            val resDirectory = launches.listFiles()?.maxByOrNull {
-                LocalDateTime.parse(it.name).atZone(ZoneId.systemDefault()).toInstant()
-            }
-
-            if (resDirectory == null || !(resDirectory.resolve("jvm.json")).exists()) {
-                "> **Can't find appropriate benchmark data. Try generating readme files after running benchmarks**."
-            } else {
-                val reports: List<JmhReport> =
-                    jsonMapper.readValue<List<JmhReport>>(resDirectory.resolve("jvm.json"))
-
-                buildString {
-                    appendLine("## Report for benchmark configuration <code>${cfg.name}</code>")
-                    appendLine()
-                    val first = reports.first()
-
-                    appendLine("* Run on ${first.vmName} (build ${first.vmVersion}) with Java process:")
-                    appendLine()
-                    appendLine("```")
-                    appendLine(
-                        "${first.jvm} ${
-                            first.jvmArgs.joinToString(" ")
-                        }"
-                    )
-                    appendLine("```")
-
-                    appendLine(
-                        "* JMH ${first.jmhVersion} was used in `${first.mode}` mode with ${first.warmupIterations} warmup ${
-                            noun(first.warmupIterations, "iteration", "iterations")
-                        } by ${first.warmupTime} and ${first.measurementIterations} measurement ${
-                            noun(first.measurementIterations, "iteration", "iterations")
-                        } by ${first.measurementTime}."
-                    )
-
-                    reports.groupBy { it.benchmark.substringBeforeLast(".") }.forEach { (cl, compare) ->
-                        appendLine("### [${cl.substringAfterLast(".")}](src/jvmMain/kotlin/${cl.replace(".","/")}.kt)")
-                        appendLine()
-                        appendLine("| Benchmark | Score |")
-                        appendLine("|:---------:|:-----:|")
-                        compare.forEach { report ->
-                            val benchmarkName = report.benchmark.substringAfterLast(".")
-                            val score = String.format("%.2G", report.primaryMetric.score)
-                            val error = String.format("%.2G", report.primaryMetric.scoreError)
-
-                            appendLine("|`$benchmarkName`|$score &plusmn; $error ${report.primaryMetric.scoreUnit}|")
-                        }
-                    }
-                }
-            }
-        }
-    }
 }
+
+addBenchmarkProperties()
--- a/benchmarks/docs/README-TEMPLATE.md
+++ b/benchmarks/docs/README-TEMPLATE.md
@ -1,5 +0,0 @@
-# BenchmarksResult
-
-${benchmarkMain}
-
-
--- a/benchmarks/src/jsMain/kotlin/space/kscience/kmath/benchmarks/ExpressionsInterpretersBenchmark.kt
+++ b/benchmarks/src/jsMain/kotlin/space/kscience/kmath/benchmarks/ExpressionsInterpretersBenchmark.kt
@ -14,7 +14,6 @@ import space.kscience.kmath.expressions.*
 import space.kscience.kmath.operations.Float64Field
 import space.kscience.kmath.operations.bindSymbol
 import space.kscience.kmath.operations.invoke
-import space.kscience.kmath.structures.Float64
 import kotlin.math.sin
 import kotlin.random.Random
 import space.kscience.kmath.estree.compileToExpression as estreeCompileToExpression
@ -68,7 +67,7 @@ class ExpressionsInterpretersBenchmark {
        blackhole.consume(sum)
    }

-    private fun invokeAndSum(expr: Expression<Float64>, blackhole: Blackhole) {
+    private fun invokeAndSum(expr: Expression<Double>, blackhole: Blackhole) {
        val random = Random(0)
        var sum = 0.0
        val m = HashMap<Symbol, Double>()
@ -100,7 +99,7 @@ class ExpressionsInterpretersBenchmark {
        private val wasm = node.wasmCompileToExpression(Float64Field)
        private val estree = node.estreeCompileToExpression(Float64Field)

-        private val raw = Expression<Float64> { args ->
+        private val raw = Expression<Double> { args ->
            val x = args.getValue(x)
            x * 2.0 + 2.0 / x - 16.0 / sin(x)
        }
--- a/benchmarks/src/jvmMain/kotlin/space/kscience/kmath/benchmarks/ExpressionsInterpretersBenchmark.kt
+++ b/benchmarks/src/jvmMain/kotlin/space/kscience/kmath/benchmarks/ExpressionsInterpretersBenchmark.kt
@ -15,7 +15,6 @@ import space.kscience.kmath.operations.Algebra
 import space.kscience.kmath.operations.Float64Field
 import space.kscience.kmath.operations.bindSymbol
 import space.kscience.kmath.operations.invoke
-import space.kscience.kmath.structures.Float64
 import kotlin.math.sin
 import kotlin.random.Random

@ -84,7 +83,7 @@ internal class ExpressionsInterpretersBenchmark {
        blackhole.consume(sum)
    }

-    private fun invokeAndSum(expr: Expression<Float64>, blackhole: Blackhole) {
+    private fun invokeAndSum(expr: Expression<Double>, blackhole: Blackhole) {
        val random = Random(0)
        var sum = 0.0
        val m = HashMap<Symbol, Double>()
@ -115,9 +114,9 @@ internal class ExpressionsInterpretersBenchmark {
        private val asmPrimitive = node.compileToExpression(Float64Field)
        private val xIdx = asmPrimitive.indexer.indexOf(x)

-        private val asmGeneric = node.compileToExpression(Float64Field as Algebra<Float64>)
+        private val asmGeneric = node.compileToExpression(Float64Field as Algebra<Double>)

-        private val raw = Expression<Float64> { args ->
+        private val raw = Expression<Double> { args ->
            val x = args[x]!!
            x * 2.0 + 2.0 / x - 16.0 / sin(x)
        }
--- a/benchmarks/src/jvmMain/kotlin/space/kscience/kmath/benchmarks/NDFieldBenchmark.kt
+++ b/benchmarks/src/jvmMain/kotlin/space/kscience/kmath/benchmarks/NDFieldBenchmark.kt
@ -17,7 +17,6 @@ import space.kscience.kmath.UnsafeKMathAPI
 import space.kscience.kmath.nd.*
 import space.kscience.kmath.nd4j.nd4j
 import space.kscience.kmath.operations.Float64Field
-import space.kscience.kmath.structures.Float64
 import space.kscience.kmath.tensors.core.DoubleTensor
 import space.kscience.kmath.tensors.core.one
 import space.kscience.kmath.tensors.core.tensorAlgebra
@ -38,28 +37,28 @@ internal class NDFieldBenchmark {

    @Benchmark
    fun specializedFieldAdd(blackhole: Blackhole) = with(specializedField) {
-        var res: StructureND<Float64> = one(shape)
+        var res: StructureND<Double> = one(shape)
        repeat(n) { res += 1.0 }
        blackhole.consume(res)
    }

    @Benchmark
    fun boxingFieldAdd(blackhole: Blackhole) = with(genericField) {
-        var res: StructureND<Float64> = one(shape)
+        var res: StructureND<Double> = one(shape)
        repeat(n) { res += 1.0 }
        blackhole.consume(res)
    }

    @Benchmark
    fun multikAdd(blackhole: Blackhole) = with(multikAlgebra) {
-        var res: StructureND<Float64> = one(shape)
+        var res: StructureND<Double> = one(shape)
        repeat(n) { res += 1.0 }
        blackhole.consume(res)
    }

    @Benchmark
    fun viktorAdd(blackhole: Blackhole) = with(viktorField) {
-        var res: StructureND<Float64> = one(shape)
+        var res: StructureND<Double> = one(shape)
        repeat(n) { res += 1.0 }
        blackhole.consume(res)
    }
@ -88,7 +87,7 @@ internal class NDFieldBenchmark {

 //    @Benchmark
 //    fun nd4jAdd(blackhole: Blackhole) = with(nd4jField) {
-//        var res: StructureND<Float64> = one(dim, dim)
+//        var res: StructureND<Double> = one(dim, dim)
 //        repeat(n) { res += 1.0 }
 //        blackhole.consume(res)
 //    }
--- a/benchmarks/src/jvmMain/kotlin/space/kscience/kmath/benchmarks/ViktorBenchmark.kt
+++ b/benchmarks/src/jvmMain/kotlin/space/kscience/kmath/benchmarks/ViktorBenchmark.kt
@ -15,7 +15,6 @@ import space.kscience.kmath.nd.StructureND
 import space.kscience.kmath.nd.ndAlgebra
 import space.kscience.kmath.nd.one
 import space.kscience.kmath.operations.Float64Field
-import space.kscience.kmath.structures.Float64
 import space.kscience.kmath.viktor.ViktorFieldND

@State(Scope.Benchmark)
@ -24,7 +23,7 @@ internal class ViktorBenchmark {
    @Benchmark
    fun doubleFieldAddition(blackhole: Blackhole) {
        with(doubleField) {
-            var res: StructureND<Float64> = one(shape)
+            var res: StructureND<Double> = one(shape)
            repeat(n) { res += 1.0 }
            blackhole.consume(res)
        }
--- a/build.gradle.kts
+++ b/build.gradle.kts
@ -2,7 +2,7 @@ import space.kscience.gradle.useApache2Licence
 import space.kscience.gradle.useSPCTeam

 plugins {
-    alias(spclibs.plugins.kscience.project)
+    id("space.kscience.gradle.project")
    alias(spclibs.plugins.kotlinx.kover)
 }

--- a/buildSrc/build.gradle.kts
+++ b/buildSrc/build.gradle.kts
@ -0,0 +1,33 @@
+plugins {
+    kotlin("jvm") version "1.9.23"
+    `kotlin-dsl`
+    `version-catalog`
+}
+
+repositories {
+    mavenLocal()
+    maven("https://repo.kotlin.link")
+    mavenCentral()
+    gradlePluginPortal()
+}
+
+val toolsVersion = spclibs.versions.tools.get()
+val kotlinVersion = spclibs.versions.kotlin.asProvider().get()
+val benchmarksVersion = spclibs.versions.kotlinx.benchmark.get()
+
+dependencies {
+    api("space.kscience:gradle-tools:$toolsVersion")
+    //plugins form benchmarks
+    api("org.jetbrains.kotlinx:kotlinx-benchmark-plugin:$benchmarksVersion")
+    //api("org.jetbrains.kotlin:kotlin-allopen:$kotlinVersion")
+    //to be used inside build-script only
+    //implementation(spclibs.kotlinx.serialization.json)
+    implementation("com.fasterxml.jackson.module:jackson-module-kotlin:2.14.+")
+}
+
+kotlin {
+    jvmToolchain(11)
+    compilerOptions {
+        optIn.add("kotlin.OptIn")
+    }
+}
--- a/buildSrc/settings.gradle.kts
+++ b/buildSrc/settings.gradle.kts
@ -0,0 +1,38 @@
+/*
+ * Copyright 2018-2021 KMath contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+enableFeaturePreview("TYPESAFE_PROJECT_ACCESSORS")
+
+plugins {
+    id("org.gradle.toolchains.foojay-resolver-convention") version "0.8.0"
+}
+
+dependencyResolutionManagement {
+    val projectProperties = java.util.Properties()
+    file("../gradle.properties").inputStream().use {
+        projectProperties.load(it)
+    }
+
+    projectProperties.forEach { key, value ->
+        extra.set(key.toString(), value)
+    }
+
+
+    val toolsVersion: String = projectProperties["toolsVersion"].toString()
+
+    @Suppress("UnstableApiUsage")
+    repositories {
+        mavenLocal()
+        maven("https://repo.kotlin.link")
+        mavenCentral()
+        gradlePluginPortal()
+    }
+
+    versionCatalogs {
+        create("spclibs") {
+            from("space.kscience:version-catalog:$toolsVersion")
+        }
+    }
+}
--- a/buildSrc/src/main/kotlin/space/kscience/kmath/benchmarks/JmhReport.kt
+++ b/buildSrc/src/main/kotlin/space/kscience/kmath/benchmarks/JmhReport.kt
@ -0,0 +1,55 @@
+/*
+ * Copyright 2018-2024 KMath contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package space.kscience.kmath.benchmarks
+
+data class JmhReport(
+    val jmhVersion: String,
+    val benchmark: String,
+    val mode: String,
+    val threads: Int,
+    val forks: Int,
+    val jvm: String,
+    val jvmArgs: List<String>,
+    val jdkVersion: String,
+    val vmName: String,
+    val vmVersion: String,
+    val warmupIterations: Int,
+    val warmupTime: String,
+    val warmupBatchSize: Int,
+    val measurementIterations: Int,
+    val measurementTime: String,
+    val measurementBatchSize: Int,
+    val params: Map<String, String> = emptyMap(),
+    val primaryMetric: PrimaryMetric,
+    val secondaryMetrics: Map<String, SecondaryMetric>,
+) {
+    interface Metric {
+        val score: Double
+        val scoreError: Double
+        val scoreConfidence: List<Double>
+        val scorePercentiles: Map<Double, Double>
+        val scoreUnit: String
+    }
+
+    data class PrimaryMetric(
+        override val score: Double,
+        override val scoreError: Double,
+        override val scoreConfidence: List<Double>,
+        override val scorePercentiles: Map<Double, Double>,
+        override val scoreUnit: String,
+        val rawDataHistogram: List<List<List<List<Double>>>>? = null,
+        val rawData: List<List<Double>>? = null,
+    ) : Metric
+
+    data class SecondaryMetric(
+        override val score: Double,
+        override val scoreError: Double,
+        override val scoreConfidence: List<Double>,
+        override val scorePercentiles: Map<Double, Double>,
+        override val scoreUnit: String,
+        val rawData: List<List<Double>>,
+    ) : Metric
+}
--- a/buildSrc/src/main/kotlin/space/kscience/kmath/benchmarks/addBenchmarkProperties.kt
+++ b/buildSrc/src/main/kotlin/space/kscience/kmath/benchmarks/addBenchmarkProperties.kt
@ -0,0 +1,110 @@
+/*
+ * Copyright 2018-2024 KMath contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package space.kscience.kmath.benchmarks
+
+import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
+import com.fasterxml.jackson.module.kotlin.readValue
+import kotlinx.benchmark.gradle.BenchmarksExtension
+import org.gradle.api.Project
+import space.kscience.gradle.KScienceReadmeExtension
+import java.time.LocalDateTime
+import java.time.ZoneId
+import java.time.format.DateTimeFormatter
+import java.time.format.DateTimeFormatterBuilder
+import java.time.format.SignStyle
+import java.time.temporal.ChronoField.*
+import java.util.*
+
+private val ISO_DATE_TIME: DateTimeFormatter = DateTimeFormatterBuilder().run {
+    parseCaseInsensitive()
+    appendValue(YEAR, 4, 10, SignStyle.EXCEEDS_PAD)
+    appendLiteral('-')
+    appendValue(MONTH_OF_YEAR, 2)
+    appendLiteral('-')
+    appendValue(DAY_OF_MONTH, 2)
+    appendLiteral('T')
+    appendValue(HOUR_OF_DAY, 2)
+    appendLiteral('.')
+    appendValue(MINUTE_OF_HOUR, 2)
+    optionalStart()
+    appendLiteral('.')
+    appendValue(SECOND_OF_MINUTE, 2)
+    optionalStart()
+    appendFraction(NANO_OF_SECOND, 0, 9, true)
+    optionalStart()
+    appendOffsetId()
+    optionalStart()
+    appendLiteral('[')
+    parseCaseSensitive()
+    appendZoneRegionId()
+    appendLiteral(']')
+    toFormatter()
+}
+
+private fun noun(number: Number, singular: String, plural: String) = if (number.toLong() == 1L) singular else plural
+
+private val jsonMapper = jacksonObjectMapper()
+
+fun Project.addBenchmarkProperties() {
+    val benchmarksProject = this
+    rootProject.subprojects.forEach { p ->
+        p.extensions.findByType(KScienceReadmeExtension::class.java)?.run {
+            benchmarksProject.extensions.findByType(BenchmarksExtension::class.java)?.configurations?.forEach { cfg ->
+                property("benchmark${cfg.name.replaceFirstChar { if (it.isLowerCase()) it.titlecase(Locale.getDefault()) else it.toString() }}") {
+                    val launches = benchmarksProject.layout.buildDirectory.dir("reports/benchmarks/${cfg.name}").get()
+
+                    val resDirectory = launches.files().maxByOrNull {
+                        LocalDateTime.parse(it.name, ISO_DATE_TIME).atZone(ZoneId.systemDefault()).toInstant()
+                    }
+
+                    if (resDirectory == null || !(resDirectory.resolve("jvm.json")).exists()) {
+                        "> **Can't find appropriate benchmark data. Try generating readme files after running benchmarks**."
+                    } else {
+                        val reports: List<JmhReport> =
+                            jsonMapper.readValue<List<JmhReport>>(resDirectory.resolve("jvm.json"))
+
+                        buildString {
+                            appendLine("<details>")
+                            appendLine("<summary>")
+                            appendLine("Report for benchmark configuration <code>${cfg.name}</code>")
+                            appendLine("</summary>")
+                            appendLine()
+                            val first = reports.first()
+
+                            appendLine("* Run on ${first.vmName} (build ${first.vmVersion}) with Java process:")
+                            appendLine()
+                            appendLine("```")
+                            appendLine(
+                                "${first.jvm} ${
+                                    first.jvmArgs.joinToString(" ")
+                                }"
+                            )
+                            appendLine("```")
+
+                            appendLine(
+                                "* JMH ${first.jmhVersion} was used in `${first.mode}` mode with ${first.warmupIterations} warmup ${
+                                    noun(first.warmupIterations, "iteration", "iterations")
+                                } by ${first.warmupTime} and ${first.measurementIterations} measurement ${
+                                    noun(first.measurementIterations, "iteration", "iterations")
+                                } by ${first.measurementTime}."
+                            )
+
+                            appendLine()
+                            appendLine("| Benchmark | Score |")
+                            appendLine("|:---------:|:-----:|")
+
+                            reports.forEach { report ->
+                                appendLine("|`${report.benchmark}`|${report.primaryMetric.score} &plusmn; ${report.primaryMetric.scoreError} ${report.primaryMetric.scoreUnit}|")
+                            }
+
+                            appendLine("</details>")
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
--- a/docs/nd-structure.md
+++ b/docs/nd-structure.md
@ -31,7 +31,7 @@ The code to run this looks like:

 ```kotlin
    specializedField.run {
-        var res: NDBuffer<Float64> = one
+        var res: NDBuffer<Double> = one
        repeat(n) {
            res += 1.0
        }
@ -103,7 +103,7 @@ The boxing field produced by

 ```kotlin
    genericField.run {
-        var res: NDBuffer<Float64> = one
+        var res: NDBuffer<Double> = one
        repeat(n) {
            res += 1.0
        }
--- a/examples/src/main/kotlin/space/kscience/kmath/functions/integrate.kt
+++ b/examples/src/main/kotlin/space/kscience/kmath/functions/integrate.kt
@ -14,12 +14,11 @@ import space.kscience.kmath.integration.gaussIntegrator
 import space.kscience.kmath.integration.integrate
 import space.kscience.kmath.integration.value
 import space.kscience.kmath.operations.Float64Field
-import space.kscience.kmath.structures.Float64
 import kotlin.math.pow

 fun main() {
    //Define a function
-    val function: Function1D<Float64> = { x -> 3 * x.pow(2) + 2 * x + 1 }
+    val function: Function1D<Double> = { x -> 3 * x.pow(2) + 2 * x + 1 }

    //get the result of the integration
    val result = Float64Field.gaussIntegrator.integrate(0.0..10.0, function = function)
--- a/examples/src/main/kotlin/space/kscience/kmath/functions/interpolate.kt
+++ b/examples/src/main/kotlin/space/kscience/kmath/functions/interpolate.kt
@ -8,7 +8,6 @@ package space.kscience.kmath.functions
 import space.kscience.kmath.interpolation.SplineInterpolator
 import space.kscience.kmath.interpolation.interpolatePolynomials
 import space.kscience.kmath.operations.Float64Field
-import space.kscience.kmath.structures.Float64
 import space.kscience.plotly.Plotly
 import space.kscience.plotly.UnstablePlotlyAPI
 import space.kscience.plotly.makeFile
@ -24,7 +23,7 @@ fun main() {
        x to sin(x)
    }

-    val polynomial: PiecewisePolynomial<Float64> = SplineInterpolator(Float64Field).interpolatePolynomials(data)
+    val polynomial: PiecewisePolynomial<Double> = SplineInterpolator(Float64Field).interpolatePolynomials(data)

    val function = polynomial.asFunction(Float64Field, 0.0)

--- a/examples/src/main/kotlin/space/kscience/kmath/functions/interpolateSquare.kt
+++ b/examples/src/main/kotlin/space/kscience/kmath/functions/interpolateSquare.kt
@ -10,7 +10,6 @@ import space.kscience.kmath.interpolation.splineInterpolator
 import space.kscience.kmath.operations.Float64Field
 import space.kscience.kmath.real.map
 import space.kscience.kmath.real.step
-import space.kscience.kmath.structures.Float64
 import space.kscience.plotly.Plotly
 import space.kscience.plotly.UnstablePlotlyAPI
 import space.kscience.plotly.makeFile
@ -19,7 +18,7 @@ import space.kscience.plotly.scatter

@OptIn(UnstablePlotlyAPI::class)
 fun main() {
-    val function: Function1D<Float64> = { x ->
+    val function: Function1D<Double> = { x ->
        if (x in 30.0..50.0) {
            1.0
        } else {
@ -29,7 +28,7 @@ fun main() {
    val xs = 0.0..100.0 step 0.5
    val ys = xs.map(function)

-    val polynomial: PiecewisePolynomial<Float64> = Float64Field.splineInterpolator.interpolatePolynomials(xs, ys)
+    val polynomial: PiecewisePolynomial<Double> = Float64Field.splineInterpolator.interpolatePolynomials(xs, ys)

    val polyFunction = polynomial.asFunction(Float64Field, 0.0)

--- a/examples/src/main/kotlin/space/kscience/kmath/functions/matrixIntegration.kt
+++ b/examples/src/main/kotlin/space/kscience/kmath/functions/matrixIntegration.kt
@ -12,7 +12,6 @@ import space.kscience.kmath.nd.StructureND
 import space.kscience.kmath.nd.structureND
 import space.kscience.kmath.nd.withNdAlgebra
 import space.kscience.kmath.operations.algebra
-import space.kscience.kmath.structures.Float64
 import kotlin.math.pow

 fun main(): Unit = Double.algebra.withNdAlgebra(2, 2) {
@ -23,7 +22,7 @@ fun main(): Unit = Double.algebra.withNdAlgebra(2, 2) {
    }

    //Define a function in a nd space
-    val function: (Double) -> StructureND<Float64> = { x: Double -> 3 * x.pow(2) + 2 * diagonal(x) + 1 }
+    val function: (Double) -> StructureND<Double> = { x: Double -> 3 * x.pow(2) + 2 * diagonal(x) + 1 }

    //get the result of the integration
    val result = gaussIntegrator.integrate(0.0..10.0, function = function)
--- a/examples/src/main/kotlin/space/kscience/kmath/linear/eigenValueDecomposition.kt
+++ b/examples/src/main/kotlin/space/kscience/kmath/linear/eigenValueDecomposition.kt
@ -1,40 +0,0 @@
-/*
- * Copyright 2018-2024 KMath contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package space.kscience.kmath.linear
-
-import space.kscience.kmath.commons.linear.CMLinearSpace
-import space.kscience.kmath.ejml.EjmlLinearSpaceDDRM
-import space.kscience.kmath.nd.StructureND
-import space.kscience.kmath.operations.algebra
-import space.kscience.kmath.structures.Float64
-import kotlin.random.Random
-
-fun main() {
-    val dim = 46
-
-    val random = Random(123)
-
-    val u = Float64.algebra.linearSpace.buildMatrix(dim, dim) { i, j -> if (i <= j) random.nextDouble() else 0.0 }
-
-    listOf(CMLinearSpace, EjmlLinearSpaceDDRM).forEach { algebra ->
-        with(algebra) {
-            //create a simmetric matrix
-            val matrix = buildMatrix(dim, dim) { row, col ->
-                if (row >= col) u[row, col] else u[col, row]
-            }
-            val eigen = matrix.getOrComputeAttribute(EIG) ?: error("Failed to compute eigenvalue decomposition")
-            check(
-                StructureND.contentEquals(
-                    matrix,
-                    eigen.v dot eigen.d dot eigen.v.transposed(),
-                    1e-4
-                )
-            ) { "$algebra decomposition failed" }
-            println("$algebra eigenvalue decomposition complete and checked" )
-        }
-    }
-
-}
--- a/examples/src/main/kotlin/space/kscience/kmath/linear/gradient.kt
+++ b/examples/src/main/kotlin/space/kscience/kmath/linear/gradient.kt
@ -6,19 +6,18 @@
 package space.kscience.kmath.linear

 import space.kscience.kmath.real.*
-import space.kscience.kmath.structures.Float64
 import space.kscience.kmath.structures.Float64Buffer

 fun main() {
    val x0 = DoubleVector(0.0, 0.0, 0.0)
    val sigma = DoubleVector(1.0, 1.0, 1.0)

-    val gaussian: (Point<Float64>) -> Double = { x ->
+    val gaussian: (Point<Double>) -> Double = { x ->
        require(x.size == x0.size)
        kotlin.math.exp(-((x - x0) / sigma).square().sum())
    }

-    fun ((Point<Float64>) -> Double).grad(x: Point<Float64>): Point<Float64> {
+    fun ((Point<Double>) -> Double).grad(x: Point<Double>): Point<Double> {
        require(x.size == x0.size)
        return Float64Buffer(x.size) { i ->
            val h = sigma[i] / 5
--- a/examples/src/main/kotlin/space/kscience/kmath/operations/mixedNDOperations.kt
+++ b/examples/src/main/kotlin/space/kscience/kmath/operations/mixedNDOperations.kt
@ -11,7 +11,6 @@ import space.kscience.kmath.nd.Float64BufferND
 import space.kscience.kmath.nd.Structure2D
 import space.kscience.kmath.nd.mutableStructureND
 import space.kscience.kmath.nd.ndAlgebra
-import space.kscience.kmath.structures.Float64
 import space.kscience.kmath.viktor.viktorAlgebra
 import kotlin.collections.component1
 import kotlin.collections.component2
@ -21,7 +20,7 @@ fun main() {
        if (i == j) 2.0 else 0.0
    }

-    val cmMatrix: Structure2D<Float64> = CMLinearSpace.matrix(2, 2)(0.0, 1.0, 0.0, 3.0)
+    val cmMatrix: Structure2D<Double> = CMLinearSpace.matrix(2, 2)(0.0, 1.0, 0.0, 3.0)

    val res: Float64BufferND = Float64Field.ndAlgebra {
        exp(viktorStructure) + 2.0 * cmMatrix
--- a/examples/src/main/kotlin/space/kscience/kmath/series/analyzeDif.kt
+++ b/examples/src/main/kotlin/space/kscience/kmath/series/analyzeDif.kt
@ -14,7 +14,6 @@ import space.kscience.kmath.operations.toList
 import space.kscience.kmath.stat.KMComparisonResult
 import space.kscience.kmath.stat.ksComparisonStatistic
 import space.kscience.kmath.structures.Buffer
-import space.kscience.kmath.structures.Float64
 import space.kscience.kmath.structures.slice
 import space.kscience.plotly.*
 import kotlin.math.PI
@ -25,7 +24,7 @@ fun Double.Companion.seriesAlgebra() = Double.algebra.bufferAlgebra.seriesAlgebr
 fun main() = with(Double.seriesAlgebra()) {


-    fun Plot.plotSeries(name: String, buffer: Buffer<Float64>) {
+    fun Plot.plotSeries(name: String, buffer: Buffer<Double>) {
        scatter {
            this.name = name
            x.numbers = buffer.labels
@ -38,10 +37,10 @@ fun main() = with(Double.seriesAlgebra()) {

    val s2 = s1.slice(20..50).moveTo(40)

-    val s3: Buffer<Float64> = s1.zip(s2) { l, r -> l + r } //s1 + s2
+    val s3: Buffer<Double> = s1.zip(s2) { l, r -> l + r } //s1 + s2
    val s4 = s3.map { ln(it) }

-    val kmTest: KMComparisonResult<Float64> = ksComparisonStatistic(s1, s2)
+    val kmTest: KMComparisonResult<Double> = ksComparisonStatistic(s1, s2)

    Plotly.page {
        h1 { +"This is my plot" }
--- a/examples/src/main/kotlin/space/kscience/kmath/series/seriesBuilder.kt
+++ b/examples/src/main/kotlin/space/kscience/kmath/series/seriesBuilder.kt
@ -6,7 +6,10 @@
 package space.kscience.kmath.series


-import space.kscience.kmath.structures.*
+import space.kscience.kmath.structures.Buffer
+import space.kscience.kmath.structures.Float64Buffer
+import space.kscience.kmath.structures.asBuffer
+import space.kscience.kmath.structures.toDoubleArray
 import space.kscience.plotly.*
 import space.kscience.plotly.models.Scatter
 import space.kscience.plotly.models.ScatterMode
@ -19,7 +22,7 @@ fun main(): Unit = with(Double.seriesAlgebra()) {
    val arrayOfRandoms = DoubleArray(20) { random.nextDouble() }

    val series1: Float64Buffer = arrayOfRandoms.asBuffer()
-    val series2: Series<Float64> = series1.moveBy(3)
+    val series2: Series<Double> = series1.moveBy(3)

    val res = series2 - series1

@ -27,7 +30,7 @@ fun main(): Unit = with(Double.seriesAlgebra()) {

    println(res)

-    fun Plot.series(name: String, buffer: Buffer<Float64>, block: Scatter.() -> Unit = {}) {
+    fun Plot.series(name: String, buffer: Buffer<Double>, block: Scatter.() -> Unit = {}) {
        scatter {
            this.name = name
            x.numbers = buffer.offsetIndices
--- a/examples/src/main/kotlin/space/kscience/kmath/stat/DistributionBenchmark.kt
+++ b/examples/src/main/kotlin/space/kscience/kmath/stat/DistributionBenchmark.kt
@ -36,28 +36,8 @@ private suspend fun runKMathChained(): Duration {
    return Duration.between(startTime, Instant.now())
 }

-private fun runKMathBlocking(): Duration {
-    val generator = RandomGenerator.fromSource(RandomSource.MT, 123L)
-    val normal = GaussianSampler(7.0, 2.0)
-    val chain = normal.sample(generator)
-    val startTime = Instant.now()
-    var sum = 0.0
-
-    repeat(10000001) { counter ->
-        sum += chain.nextBlocking()
-
-        if (counter % 100000 == 0) {
-            val duration = Duration.between(startTime, Instant.now())
-            val meanValue = sum / counter
-            println("Chain sampler completed $counter elements in $duration: $meanValue")
-        }
-    }
-
-    return Duration.between(startTime, Instant.now())
-}
-
 private fun runCMDirect(): Duration {
-    val rng = RandomSource.MT.create(123L)
+    val rng = RandomSource.create(RandomSource.MT, 123L)

    val sampler = CMGaussianSampler.of(
        BoxMullerNormalizedGaussianSampler.of(rng),
@ -87,8 +67,6 @@ private fun runCMDirect(): Duration {
 fun main(): Unit = runBlocking(Dispatchers.Default) {
    val directJob = async { runCMDirect() }
    val chainJob = async { runKMathChained() }
-    val blockingJob = async { runKMathBlocking() }
    println("KMath Chained: ${chainJob.await()}")
-    println("KMath Blocking: ${blockingJob.await()}")
    println("Apache Direct: ${directJob.await()}")
 }
--- a/examples/src/main/kotlin/space/kscience/kmath/stat/DistributionDemo.kt
+++ b/examples/src/main/kotlin/space/kscience/kmath/stat/DistributionDemo.kt
@ -10,14 +10,13 @@ import space.kscience.kmath.chains.Chain
 import space.kscience.kmath.chains.combineWithState
 import space.kscience.kmath.distributions.NormalDistribution
 import space.kscience.kmath.random.RandomGenerator
-import space.kscience.kmath.structures.Float64

 private data class AveragingChainState(var num: Int = 0, var value: Double = 0.0)

 /**
 * Averaging.
 */
-private fun Chain<Float64>.mean(): Chain<Float64> = combineWithState(AveragingChainState(), { it.copy() }) { chain ->
+private fun Chain<Double>.mean(): Chain<Double> = combineWithState(AveragingChainState(), { it.copy() }) { chain ->
    val next = chain.next()
    num++
    value += next
--- a/examples/src/main/kotlin/space/kscience/kmath/structures/ComplexND.kt
+++ b/examples/src/main/kotlin/space/kscience/kmath/structures/ComplexND.kt
@ -26,7 +26,7 @@ fun main() {

    val realTime = measureTimeMillis {
        realField {
-            var res: StructureND<Float64> = one
+            var res: StructureND<Double> = one
            repeat(n) {
                res += 1.0
            }
--- a/examples/src/main/kotlin/space/kscience/kmath/structures/NDField.kt
+++ b/examples/src/main/kotlin/space/kscience/kmath/structures/NDField.kt
@ -45,35 +45,35 @@ fun main() {

    measureAndPrint("Boxing addition") {
        genericField {
-            var res: StructureND<Float64> = one(shape)
+            var res: StructureND<Double> = one(shape)
            repeat(n) { res += 1.0 }
        }
    }

    measureAndPrint("Specialized addition") {
        doubleField {
-            var res: StructureND<Float64> = one(shape)
+            var res: StructureND<Double> = one(shape)
            repeat(n) { res += 1.0 }
        }
    }

    measureAndPrint("Nd4j specialized addition") {
        nd4jField {
-            var res: StructureND<Float64> = one(shape)
+            var res: StructureND<Double> = one(shape)
            repeat(n) { res += 1.0 }
        }
    }

    measureAndPrint("Viktor addition") {
        viktorField {
-            var res: StructureND<Float64> = one
+            var res: StructureND<Double> = one
            repeat(n) { res += 1.0 }
        }
    }

    measureAndPrint("Parallel stream addition") {
        parallelField {
-            var res: StructureND<Float64> = one
+            var res: StructureND<Double> = one
            repeat(n) { res += 1.0 }
        }
    }
--- a/examples/src/main/kotlin/space/kscience/kmath/structures/StreamDoubleFieldND.kt
+++ b/examples/src/main/kotlin/space/kscience/kmath/structures/StreamDoubleFieldND.kt
@ -19,21 +19,21 @@ import java.util.stream.IntStream
 * execution.
 */
 class StreamDoubleFieldND(override val shape: ShapeND) : FieldND<Double, Float64Field>,
-    NumbersAddOps<StructureND<Float64>>,
-    ExtendedField<StructureND<Float64>> {
+    NumbersAddOps<StructureND<Double>>,
+    ExtendedField<StructureND<Double>> {

    private val strides = ColumnStrides(shape)
    override val elementAlgebra: Float64Field get() = Float64Field
-    override val zero: BufferND<Float64> by lazy { structureND(shape) { zero } }
-    override val one: BufferND<Float64> by lazy { structureND(shape) { one } }
+    override val zero: BufferND<Double> by lazy { structureND(shape) { zero } }
+    override val one: BufferND<Double> by lazy { structureND(shape) { one } }

-    override fun number(value: Number): BufferND<Float64> {
+    override fun number(value: Number): BufferND<Double> {
        val d = value.toDouble() // minimize conversions
        return structureND(shape) { d }
    }

    @OptIn(PerformancePitfall::class)
-    private val StructureND<Float64>.buffer: Float64Buffer
+    private val StructureND<Double>.buffer: Float64Buffer
        get() = when {
            shape != this@StreamDoubleFieldND.shape -> throw ShapeMismatchException(
                this@StreamDoubleFieldND.shape,
@ -44,7 +44,7 @@ class StreamDoubleFieldND(override val shape: ShapeND) : FieldND<Double, Float64
            else -> Float64Buffer(strides.linearSize) { offset -> get(strides.index(offset)) }
        }

-    override fun structureND(shape: ShapeND, initializer: Float64Field.(IntArray) -> Double): BufferND<Float64> {
+    override fun structureND(shape: ShapeND, initializer: Float64Field.(IntArray) -> Double): BufferND<Double> {
        val array = IntStream.range(0, strides.linearSize).parallel().mapToDouble { offset ->
            val index = strides.index(offset)
            Float64Field.initializer(index)
@ -56,7 +56,7 @@ class StreamDoubleFieldND(override val shape: ShapeND) : FieldND<Double, Float64
    override fun mutableStructureND(
        shape: ShapeND,
        initializer: DoubleField.(IntArray) -> Double,
-    ): MutableBufferND<Float64> {
+    ): MutableBufferND<Double> {
        val array = IntStream.range(0, strides.linearSize).parallel().mapToDouble { offset ->
            val index = strides.index(offset)
            DoubleField.initializer(index)
@ -66,17 +66,17 @@ class StreamDoubleFieldND(override val shape: ShapeND) : FieldND<Double, Float64
    }

    @OptIn(PerformancePitfall::class)
-    override fun StructureND<Float64>.map(
+    override fun StructureND<Double>.map(
        transform: Float64Field.(Double) -> Double,
-    ): BufferND<Float64> {
+    ): BufferND<Double> {
        val array = Arrays.stream(buffer.array).parallel().map { Float64Field.transform(it) }.toArray()
        return BufferND(strides, array.asBuffer())
    }

    @OptIn(PerformancePitfall::class)
-    override fun StructureND<Float64>.mapIndexed(
+    override fun StructureND<Double>.mapIndexed(
        transform: Float64Field.(index: IntArray, Double) -> Double,
-    ): BufferND<Float64> {
+    ): BufferND<Double> {
        val array = IntStream.range(0, strides.linearSize).parallel().mapToDouble { offset ->
            Float64Field.transform(
                strides.index(offset),
@ -89,39 +89,39 @@ class StreamDoubleFieldND(override val shape: ShapeND) : FieldND<Double, Float64

    @OptIn(PerformancePitfall::class)
    override fun zip(
-        left: StructureND<Float64>,
-        right: StructureND<Float64>,
+        left: StructureND<Double>,
+        right: StructureND<Double>,
        transform: Float64Field.(Double, Double) -> Double,
-    ): BufferND<Float64> {
+    ): BufferND<Double> {
        val array = IntStream.range(0, strides.linearSize).parallel().mapToDouble { offset ->
            Float64Field.transform(left.buffer.array[offset], right.buffer.array[offset])
        }.toArray()
        return BufferND(strides, array.asBuffer())
    }

-    override fun StructureND<Float64>.unaryMinus(): StructureND<Float64> = map { -it }
+    override fun StructureND<Double>.unaryMinus(): StructureND<Double> = map { -it }

-    override fun scale(a: StructureND<Float64>, value: Double): StructureND<Float64> = a.map { it * value }
+    override fun scale(a: StructureND<Double>, value: Double): StructureND<Double> = a.map { it * value }

-    override fun power(arg: StructureND<Float64>, pow: Number): BufferND<Float64> = arg.map { power(it, pow) }
+    override fun power(arg: StructureND<Double>, pow: Number): BufferND<Double> = arg.map { power(it, pow) }

-    override fun exp(arg: StructureND<Float64>): BufferND<Float64> = arg.map { exp(it) }
+    override fun exp(arg: StructureND<Double>): BufferND<Double> = arg.map { exp(it) }

-    override fun ln(arg: StructureND<Float64>): BufferND<Float64> = arg.map { ln(it) }
+    override fun ln(arg: StructureND<Double>): BufferND<Double> = arg.map { ln(it) }

-    override fun sin(arg: StructureND<Float64>): BufferND<Float64> = arg.map { sin(it) }
-    override fun cos(arg: StructureND<Float64>): BufferND<Float64> = arg.map { cos(it) }
-    override fun tan(arg: StructureND<Float64>): BufferND<Float64> = arg.map { tan(it) }
-    override fun asin(arg: StructureND<Float64>): BufferND<Float64> = arg.map { asin(it) }
-    override fun acos(arg: StructureND<Float64>): BufferND<Float64> = arg.map { acos(it) }
-    override fun atan(arg: StructureND<Float64>): BufferND<Float64> = arg.map { atan(it) }
+    override fun sin(arg: StructureND<Double>): BufferND<Double> = arg.map { sin(it) }
+    override fun cos(arg: StructureND<Double>): BufferND<Double> = arg.map { cos(it) }
+    override fun tan(arg: StructureND<Double>): BufferND<Double> = arg.map { tan(it) }
+    override fun asin(arg: StructureND<Double>): BufferND<Double> = arg.map { asin(it) }
+    override fun acos(arg: StructureND<Double>): BufferND<Double> = arg.map { acos(it) }
+    override fun atan(arg: StructureND<Double>): BufferND<Double> = arg.map { atan(it) }

-    override fun sinh(arg: StructureND<Float64>): BufferND<Float64> = arg.map { sinh(it) }
-    override fun cosh(arg: StructureND<Float64>): BufferND<Float64> = arg.map { cosh(it) }
-    override fun tanh(arg: StructureND<Float64>): BufferND<Float64> = arg.map { tanh(it) }
-    override fun asinh(arg: StructureND<Float64>): BufferND<Float64> = arg.map { asinh(it) }
-    override fun acosh(arg: StructureND<Float64>): BufferND<Float64> = arg.map { acosh(it) }
-    override fun atanh(arg: StructureND<Float64>): BufferND<Float64> = arg.map { atanh(it) }
+    override fun sinh(arg: StructureND<Double>): BufferND<Double> = arg.map { sinh(it) }
+    override fun cosh(arg: StructureND<Double>): BufferND<Double> = arg.map { cosh(it) }
+    override fun tanh(arg: StructureND<Double>): BufferND<Double> = arg.map { tanh(it) }
+    override fun asinh(arg: StructureND<Double>): BufferND<Double> = arg.map { asinh(it) }
+    override fun acosh(arg: StructureND<Double>): BufferND<Double> = arg.map { acosh(it) }
+    override fun atanh(arg: StructureND<Double>): BufferND<Double> = arg.map { atanh(it) }
 }

 fun Float64Field.ndStreaming(vararg shape: Int): StreamDoubleFieldND = StreamDoubleFieldND(ShapeND(shape))
--- a/examples/src/main/kotlin/space/kscience/kmath/structures/mutableNd.kt
+++ b/examples/src/main/kotlin/space/kscience/kmath/structures/mutableNd.kt
@ -11,7 +11,7 @@ import space.kscience.kmath.operations.algebra

@OptIn(PerformancePitfall::class)
 fun main(): Unit = with(Double.algebra.ndAlgebra) {
-    val structure: MutableStructure2D<Float64> = mutableStructureND(ShapeND(2, 2)) { (i, j) ->
+    val structure: MutableStructure2D<Double> = mutableStructureND(ShapeND(2, 2)) { (i, j) ->
        i.toDouble() + j.toDouble()
    }.as2D()

--- a/examples/src/main/kotlin/space/kscience/kmath/tensors/LevenbergMarquardt/StreamingLm/streamLm.kt
+++ b/examples/src/main/kotlin/space/kscience/kmath/tensors/LevenbergMarquardt/StreamingLm/streamLm.kt
@ -12,7 +12,6 @@ import space.kscience.kmath.nd.MutableStructure2D
 import space.kscience.kmath.nd.ShapeND
 import space.kscience.kmath.nd.as2D
 import space.kscience.kmath.nd.component1
-import space.kscience.kmath.structures.Float64
 import space.kscience.kmath.tensors.LevenbergMarquardt.StartDataLm
 import space.kscience.kmath.tensors.core.BroadcastDoubleTensorAlgebra.zeros
 import space.kscience.kmath.tensors.core.DoubleTensorAlgebra
@ -21,9 +20,9 @@ import space.kscience.kmath.tensors.core.levenbergMarquardt
 import kotlin.random.Random

 fun streamLm(
-    lm_func: (MutableStructure2D<Float64>, MutableStructure2D<Float64>, Int) -> (MutableStructure2D<Float64>),
+    lm_func: (MutableStructure2D<Double>, MutableStructure2D<Double>, Int) -> (MutableStructure2D<Double>),
    startData: StartDataLm, launchFrequencyInMs: Long, numberOfLaunches: Int,
-): Flow<MutableStructure2D<Float64>> = flow {
+): Flow<MutableStructure2D<Double>> = flow {

    var example_number = startData.example_number
    var p_init = startData.p_init
@ -65,7 +64,7 @@ fun streamLm(
    }
 }

-fun generateNewYDat(y_dat: MutableStructure2D<Float64>, delta: Double): MutableStructure2D<Float64> {
+fun generateNewYDat(y_dat: MutableStructure2D<Double>, delta: Double): MutableStructure2D<Double> {
    val n = y_dat.shape.component1()
    val y_dat_new = zeros(ShapeND(intArrayOf(n, 1))).as2D()
    for (i in 0 until n) {
--- a/examples/src/main/kotlin/space/kscience/kmath/tensors/LevenbergMarquardt/functionsToOptimize.kt
+++ b/examples/src/main/kotlin/space/kscience/kmath/tensors/LevenbergMarquardt/functionsToOptimize.kt
@ -9,7 +9,6 @@ import space.kscience.kmath.nd.MutableStructure2D
 import space.kscience.kmath.nd.ShapeND
 import space.kscience.kmath.nd.as2D
 import space.kscience.kmath.nd.component1
-import space.kscience.kmath.structures.Float64
 import space.kscience.kmath.tensors.core.BroadcastDoubleTensorAlgebra
 import space.kscience.kmath.tensors.core.BroadcastDoubleTensorAlgebra.div
 import space.kscience.kmath.tensors.core.DoubleTensorAlgebra
@ -20,24 +19,24 @@ import space.kscience.kmath.tensors.core.DoubleTensorAlgebra.Companion.times
 import space.kscience.kmath.tensors.core.asDoubleTensor

 public data class StartDataLm(
-    var lm_matx_y_dat: MutableStructure2D<Float64>,
+    var lm_matx_y_dat: MutableStructure2D<Double>,
    var example_number: Int,
-    var p_init: MutableStructure2D<Float64>,
-    var t: MutableStructure2D<Float64>,
-    var y_dat: MutableStructure2D<Float64>,
+    var p_init: MutableStructure2D<Double>,
+    var t: MutableStructure2D<Double>,
+    var y_dat: MutableStructure2D<Double>,
    var weight: Double,
-    var dp: MutableStructure2D<Float64>,
-    var p_min: MutableStructure2D<Float64>,
-    var p_max: MutableStructure2D<Float64>,
-    var consts: MutableStructure2D<Float64>,
+    var dp: MutableStructure2D<Double>,
+    var p_min: MutableStructure2D<Double>,
+    var p_max: MutableStructure2D<Double>,
+    var consts: MutableStructure2D<Double>,
    var opts: DoubleArray,
 )

 fun funcEasyForLm(
-    t: MutableStructure2D<Float64>,
-    p: MutableStructure2D<Float64>,
+    t: MutableStructure2D<Double>,
+    p: MutableStructure2D<Double>,
    exampleNumber: Int,
-): MutableStructure2D<Float64> {
+): MutableStructure2D<Double> {
    val m = t.shape.component1()
    var y_hat = DoubleTensorAlgebra.zeros(ShapeND(intArrayOf(m, 1)))

@ -60,10 +59,10 @@ fun funcEasyForLm(
 }

 fun funcMiddleForLm(
-    t: MutableStructure2D<Float64>,
-    p: MutableStructure2D<Float64>,
+    t: MutableStructure2D<Double>,
+    p: MutableStructure2D<Double>,
    exampleNumber: Int,
-): MutableStructure2D<Float64> {
+): MutableStructure2D<Double> {
    val m = t.shape.component1()
    var y_hat = DoubleTensorAlgebra.zeros(ShapeND(intArrayOf(m, 1)))

@ -80,10 +79,10 @@ fun funcMiddleForLm(
 }

 fun funcDifficultForLm(
-    t: MutableStructure2D<Float64>,
-    p: MutableStructure2D<Float64>,
+    t: MutableStructure2D<Double>,
+    p: MutableStructure2D<Double>,
    exampleNumber: Int,
-): MutableStructure2D<Float64> {
+): MutableStructure2D<Double> {
    val m = t.shape.component1()
    var y_hat = DoubleTensorAlgebra.zeros(ShapeND(intArrayOf(m, 1)))

--- a/examples/src/main/kotlin/space/kscience/kmath/tensors/multik.kt
+++ b/examples/src/main/kotlin/space/kscience/kmath/tensors/multik.kt
@ -10,13 +10,12 @@ import org.jetbrains.kotlinx.multik.api.ndarray
 import org.jetbrains.kotlinx.multik.default.DefaultEngine
 import space.kscience.kmath.multik.MultikDoubleAlgebra
 import space.kscience.kmath.nd.one
-import space.kscience.kmath.structures.Float64


 val multikAlgebra = MultikDoubleAlgebra(DefaultEngine())

 fun main(): Unit = with(multikAlgebra) {
-    val a = Multik.ndarray(intArrayOf(1, 2, 3)).asType<Float64>().wrap()
+    val a = Multik.ndarray(intArrayOf(1, 2, 3)).asType<Double>().wrap()
    val b = Multik.ndarray(doubleArrayOf(1.0, 2.0, 3.0)).wrap()
    one(a.shape) - a + b * 3.0
 }
--- a/gradle.properties
+++ b/gradle.properties
@ -11,3 +11,5 @@ org.gradle.parallel=true
 org.gradle.workers.max=4

 toolsVersion=0.15.4-kotlin-2.0.0
+#kotlin.experimental.tryK2=true
+#kscience.wasm.disabled=true
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@ -10,5 +10,3 @@ commons-rng-sampling = { module = "org.apache.commons:commons-rng-sampling", ver

 multik-core = { module = "org.jetbrains.kotlinx:multik-core", version.ref = "multik" }
 multik-default = { module = "org.jetbrains.kotlinx:multik-default", version.ref = "multik" }
-
-[plugins]
--- a/kmath-ast/src/commonTest/kotlin/space/kscience/kmath/ast/TestFolding.kt
+++ b/kmath-ast/src/commonTest/kotlin/space/kscience/kmath/ast/TestFolding.kt
@ -9,7 +9,6 @@ import space.kscience.kmath.operations.Float64Field
 import space.kscience.kmath.operations.Int32Ring
 import space.kscience.kmath.operations.Int8Ring
 import space.kscience.kmath.operations.pi
-import space.kscience.kmath.structures.Float64
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.fail
@ -42,7 +41,7 @@ internal class TestFolding {
    @Test
    fun foldSymbol() = assertEquals(
        Float64Field.pi,
-        ("pi".parseMath().evaluateConstants(Float64Field) as? TypedMst.Constant<Float64> ?: fail()).value,
+        ("pi".parseMath().evaluateConstants(Float64Field) as? TypedMst.Constant<Double> ?: fail()).value,
    )

    @Test
--- a/kmath-ast/src/commonTest/kotlin/space/kscience/kmath/ast/utils.kt
+++ b/kmath-ast/src/commonTest/kotlin/space/kscience/kmath/ast/utils.kt
@ -10,13 +10,12 @@ import space.kscience.kmath.expressions.MST
 import space.kscience.kmath.expressions.Symbol
 import space.kscience.kmath.operations.Float64Field
 import space.kscience.kmath.operations.Int32Ring
-import space.kscience.kmath.structures.Float64

 internal interface CompilerTestContext {
    fun MST.compileToExpression(algebra: Int32Ring): Expression<Int>
    fun MST.compile(algebra: Int32Ring, arguments: Map<Symbol, Int>): Int
    fun MST.compile(algebra: Int32Ring, vararg arguments: Pair<Symbol, Int>): Int = compile(algebra, mapOf(*arguments))
-    fun MST.compileToExpression(algebra: Float64Field): Expression<Float64>
+    fun MST.compileToExpression(algebra: Float64Field): Expression<Double>
    fun MST.compile(algebra: Float64Field, arguments: Map<Symbol, Double>): Double

    fun MST.compile(algebra: Float64Field, vararg arguments: Pair<Symbol, Double>): Double =
--- a/kmath-ast/src/jsMain/kotlin/space/kscience/kmath/wasm/internal/WasmBuilder.kt
+++ b/kmath-ast/src/jsMain/kotlin/space/kscience/kmath/wasm/internal/WasmBuilder.kt
@ -11,7 +11,6 @@ import space.kscience.kmath.expressions.*
 import space.kscience.kmath.internal.binaryen.*
 import space.kscience.kmath.internal.webassembly.Instance
 import space.kscience.kmath.operations.*
-import space.kscience.kmath.structures.Float64
 import space.kscience.kmath.internal.binaryen.Module as BinaryenModule
 import space.kscience.kmath.internal.webassembly.Module as WasmModule

@ -86,13 +85,13 @@ internal sealed class WasmBuilder<T : Number, out E : Expression<T>>(
 }

@UnstableKMathAPI
-internal class DoubleWasmBuilder(target: TypedMst<Float64>) :
+internal class DoubleWasmBuilder(target: TypedMst<Double>) :
    WasmBuilder<Double, DoubleExpression>(f64, Float64Field, target) {
    override val instance by lazy {
        object : DoubleExpression {
            override val indexer = SimpleSymbolIndexer(keys)

-            override fun invoke(arguments: DoubleArray) = spreader(executable, arguments).unsafeCast<Float64>()
+            override fun invoke(arguments: DoubleArray) = spreader(executable, arguments).unsafeCast<Double>()
        }
    }

@ -100,7 +99,7 @@ internal class DoubleWasmBuilder(target: TypedMst<Float64>) :

    override fun visitNumber(number: Number) = ctx.f64.const(number.toDouble())

-    override fun visitUnary(node: TypedMst.Unary<Float64>): ExpressionRef = when (node.operation) {
+    override fun visitUnary(node: TypedMst.Unary<Double>): ExpressionRef = when (node.operation) {
        GroupOps.MINUS_OPERATION -> ctx.f64.neg(visit(node.value))
        GroupOps.PLUS_OPERATION -> visit(node.value)
        PowerOperations.SQRT_OPERATION -> ctx.f64.sqrt(visit(node.value))
@ -121,7 +120,7 @@ internal class DoubleWasmBuilder(target: TypedMst<Float64>) :
        else -> super.visitUnary(node)
    }

-    override fun visitBinary(mst: TypedMst.Binary<Float64>): ExpressionRef = when (mst.operation) {
+    override fun visitBinary(mst: TypedMst.Binary<Double>): ExpressionRef = when (mst.operation) {
        GroupOps.PLUS_OPERATION -> ctx.f64.add(visit(mst.left), visit(mst.right))
        GroupOps.MINUS_OPERATION -> ctx.f64.sub(visit(mst.left), visit(mst.right))
        RingOps.TIMES_OPERATION -> ctx.f64.mul(visit(mst.left), visit(mst.right))
--- a/kmath-ast/src/jsMain/kotlin/space/kscience/kmath/wasm/wasm.kt
+++ b/kmath-ast/src/jsMain/kotlin/space/kscience/kmath/wasm/wasm.kt
@ -13,7 +13,6 @@ import space.kscience.kmath.ast.evaluateConstants
 import space.kscience.kmath.expressions.*
 import space.kscience.kmath.operations.Float64Field
 import space.kscience.kmath.operations.Int32Ring
-import space.kscience.kmath.structures.Float64
 import space.kscience.kmath.wasm.internal.DoubleWasmBuilder
 import space.kscience.kmath.wasm.internal.IntWasmBuilder

@ -59,7 +58,7 @@ public fun MST.compile(algebra: Int32Ring, vararg arguments: Pair<Symbol, Int>):
 * @author Iaroslav Postovalov
 */
@UnstableKMathAPI
-public fun MST.compileToExpression(algebra: Float64Field): Expression<Float64> {
+public fun MST.compileToExpression(algebra: Float64Field): Expression<Double> {
    val typed = evaluateConstants(algebra)

    return if (typed is TypedMst.Constant) object : DoubleExpression {
--- a/kmath-ast/src/jsTest/kotlin/space/kscience/kmath/ast/utils.kt
+++ b/kmath-ast/src/jsTest/kotlin/space/kscience/kmath/ast/utils.kt
@ -13,7 +13,6 @@ import space.kscience.kmath.expressions.MST
 import space.kscience.kmath.expressions.Symbol
 import space.kscience.kmath.operations.Float64Field
 import space.kscience.kmath.operations.Int32Ring
-import space.kscience.kmath.structures.Float64
 import kotlin.contracts.InvocationKind
 import kotlin.contracts.contract
 import space.kscience.kmath.estree.compile as estreeCompile
@ -25,7 +24,7 @@ import space.kscience.kmath.wasm.compileToExpression as wasmCompileToExpression
 private object WasmCompilerTestContext : CompilerTestContext {
    override fun MST.compileToExpression(algebra: Int32Ring): Expression<Int> = wasmCompileToExpression(algebra)
    override fun MST.compile(algebra: Int32Ring, arguments: Map<Symbol, Int>): Int = wasmCompile(algebra, arguments)
-    override fun MST.compileToExpression(algebra: Float64Field): Expression<Float64> = wasmCompileToExpression(algebra)
+    override fun MST.compileToExpression(algebra: Float64Field): Expression<Double> = wasmCompileToExpression(algebra)

    override fun MST.compile(algebra: Float64Field, arguments: Map<Symbol, Double>): Double =
        wasmCompile(algebra, arguments)
@ -34,7 +33,7 @@ private object WasmCompilerTestContext : CompilerTestContext {
 private object ESTreeCompilerTestContext : CompilerTestContext {
    override fun MST.compileToExpression(algebra: Int32Ring): Expression<Int> = estreeCompileToExpression(algebra)
    override fun MST.compile(algebra: Int32Ring, arguments: Map<Symbol, Int>): Int = estreeCompile(algebra, arguments)
-    override fun MST.compileToExpression(algebra: Float64Field): Expression<Float64> = estreeCompileToExpression(algebra)
+    override fun MST.compileToExpression(algebra: Float64Field): Expression<Double> = estreeCompileToExpression(algebra)

    override fun MST.compile(algebra: Float64Field, arguments: Map<Symbol, Double>): Double =
        estreeCompile(algebra, arguments)
--- a/kmath-ast/src/jvmMain/kotlin/space/kscience/kmath/asm/internal/PrimitiveAsmBuilder.kt
+++ b/kmath-ast/src/jvmMain/kotlin/space/kscience/kmath/asm/internal/PrimitiveAsmBuilder.kt
@ -15,7 +15,6 @@ import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.ast.TypedMst
 import space.kscience.kmath.expressions.*
 import space.kscience.kmath.operations.*
-import space.kscience.kmath.structures.Float64
 import java.lang.invoke.MethodHandles
 import java.lang.invoke.MethodType
 import java.nio.file.Paths
@ -382,7 +381,7 @@ internal sealed class PrimitiveAsmBuilder<T : Number, out E : Expression<T>>(
 }

@UnstableKMathAPI
-internal class DoubleAsmBuilder(target: TypedMst<Float64>) : PrimitiveAsmBuilder<Double, DoubleExpression>(
+internal class DoubleAsmBuilder(target: TypedMst<Double>) : PrimitiveAsmBuilder<Double, DoubleExpression>(
    Float64Field,
    java.lang.Double::class.java,
    java.lang.Double.TYPE,
@ -411,7 +410,7 @@ internal class DoubleAsmBuilder(target: TypedMst<Float64>) : PrimitiveAsmBuilder
        false,
    )

-    override fun visitUnary(node: TypedMst.Unary<Float64>) {
+    override fun visitUnary(node: TypedMst.Unary<Double>) {
        super.visitUnary(node)

        when (node.operation) {
@ -436,7 +435,7 @@ internal class DoubleAsmBuilder(target: TypedMst<Float64>) : PrimitiveAsmBuilder
        }
    }

-    override fun visitBinary(node: TypedMst.Binary<Float64>) {
+    override fun visitBinary(node: TypedMst.Binary<Double>) {
        super.visitBinary(node)

        when (node.operation) {
--- a/kmath-ast/src/jvmTest/kotlin/space/kscience/kmath/ast/utils.kt
+++ b/kmath-ast/src/jvmTest/kotlin/space/kscience/kmath/ast/utils.kt
@ -12,7 +12,6 @@ import space.kscience.kmath.expressions.Symbol
 import space.kscience.kmath.operations.Algebra
 import space.kscience.kmath.operations.Float64Field
 import space.kscience.kmath.operations.Int32Ring
-import space.kscience.kmath.structures.Float64
 import space.kscience.kmath.asm.compile as asmCompile
 import space.kscience.kmath.asm.compileToExpression as asmCompileToExpression

@ -23,18 +22,18 @@ private object GenericAsmCompilerTestContext : CompilerTestContext {
    override fun MST.compile(algebra: Int32Ring, arguments: Map<Symbol, Int>): Int =
        asmCompile(algebra as Algebra<Int>, arguments)

-    override fun MST.compileToExpression(algebra: Float64Field): Expression<Float64> =
-        asmCompileToExpression(algebra as Algebra<Float64>)
+    override fun MST.compileToExpression(algebra: Float64Field): Expression<Double> =
+        asmCompileToExpression(algebra as Algebra<Double>)

    override fun MST.compile(algebra: Float64Field, arguments: Map<Symbol, Double>): Double =
-        asmCompile(algebra as Algebra<Float64>, arguments)
+        asmCompile(algebra as Algebra<Double>, arguments)
 }

@OptIn(UnstableKMathAPI::class)
 private object PrimitiveAsmCompilerTestContext : CompilerTestContext {
    override fun MST.compileToExpression(algebra: Int32Ring): Expression<Int> = asmCompileToExpression(algebra)
    override fun MST.compile(algebra: Int32Ring, arguments: Map<Symbol, Int>): Int = asmCompile(algebra, arguments)
-    override fun MST.compileToExpression(algebra: Float64Field): Expression<Float64> = asmCompileToExpression(algebra)
+    override fun MST.compileToExpression(algebra: Float64Field): Expression<Double> = asmCompileToExpression(algebra)

    override fun MST.compile(algebra: Float64Field, arguments: Map<Symbol, Double>): Double =
        asmCompile(algebra, arguments)
--- a/kmath-commons/src/jvmMain/kotlin/space/kscience/kmath/commons/expressions/CmDsExpression.kt
+++ b/kmath-commons/src/jvmMain/kotlin/space/kscience/kmath/commons/expressions/CmDsExpression.kt
@ -14,7 +14,6 @@ import space.kscience.kmath.expressions.*
 import space.kscience.kmath.operations.DoubleField
 import space.kscience.kmath.operations.ExtendedField
 import space.kscience.kmath.operations.NumbersAddOps
-import space.kscience.kmath.structures.Float64
 import space.kscience.kmath.structures.MutableBufferFactory

 /**
@ -133,9 +132,9 @@ public object CmDsProcessor : AutoDiffProcessor<Double, DerivativeStructure, CmD
@Deprecated("Use generic DSAlgebra from the core")
 public class CmDsExpression(
    public val function: CmDsField.() -> DerivativeStructure,
-) : DifferentiableExpression<Float64> {
+) : DifferentiableExpression<Double> {

-    override val type: SafeType<Float64> get() = DoubleField.type
+    override val type: SafeType<Double> get() = DoubleField.type

    override operator fun invoke(arguments: Map<Symbol, Double>): Double =
        CmDsField(0, arguments).function().value
@ -143,7 +142,7 @@ public class CmDsExpression(
    /**
     * Get the derivative expression with given orders
     */
-    override fun derivativeOrNull(symbols: List<Symbol>): Expression<Float64> = Expression(type) { arguments ->
+    override fun derivativeOrNull(symbols: List<Symbol>): Expression<Double> = Expression(type) { arguments ->
        with(CmDsField(symbols.size, arguments)) { function().derivative(symbols) }
    }
 }
--- a/kmath-commons/src/jvmMain/kotlin/space/kscience/kmath/commons/integration/CMGaussRuleIntegrator.kt
+++ b/kmath-commons/src/jvmMain/kotlin/space/kscience/kmath/commons/integration/CMGaussRuleIntegrator.kt
@ -7,7 +7,6 @@ package space.kscience.kmath.commons.integration
 import org.apache.commons.math3.analysis.integration.gauss.GaussIntegrator
 import org.apache.commons.math3.analysis.integration.gauss.GaussIntegratorFactory
 import space.kscience.kmath.integration.*
-import space.kscience.kmath.structures.Float64

 /**
 * A simple one-pass integrator based on Gauss rule
@ -15,9 +14,9 @@ import space.kscience.kmath.structures.Float64
 public class CMGaussRuleIntegrator(
    private val numpoints: Int,
    private var type: GaussRule = GaussRule.LEGENDRE,
-) : UnivariateIntegrator<Float64> {
+) : UnivariateIntegrator<Double> {

-    override fun integrate(integrand: UnivariateIntegrand<Float64>): UnivariateIntegrand<Float64> {
+    override fun integrate(integrand: UnivariateIntegrand<Double>): UnivariateIntegrand<Double> {
        val range = integrand[IntegrationRange]
            ?: error("Integration range is not provided")
        val integrator: GaussIntegrator = getIntegrator(range)
@ -29,7 +28,7 @@ public class CMGaussRuleIntegrator(
        }
    }

-    private fun getIntegrator(range: ClosedRange<Float64>): GaussIntegrator {
+    private fun getIntegrator(range: ClosedRange<Double>): GaussIntegrator {
        return when (type) {
            GaussRule.LEGENDRE -> factory.legendre(
                numpoints,
@ -78,7 +77,7 @@ public class CMGaussRuleIntegrator(
        private val factory: GaussIntegratorFactory = GaussIntegratorFactory()

        public fun integrate(
-            range: ClosedRange<Float64>,
+            range: ClosedRange<Double>,
            numPoints: Int = 100,
            type: GaussRule = GaussRule.LEGENDRE,
            function: (Double) -> Double,
--- a/kmath-commons/src/jvmMain/kotlin/space/kscience/kmath/commons/integration/CMIntegrator.kt
+++ b/kmath-commons/src/jvmMain/kotlin/space/kscience/kmath/commons/integration/CMIntegrator.kt
@ -10,7 +10,6 @@ import org.apache.commons.math3.analysis.integration.SimpsonIntegrator
 import space.kscience.attributes.Attributes
 import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.integration.*
-import space.kscience.kmath.structures.Float64
 import org.apache.commons.math3.analysis.integration.UnivariateIntegrator as CMUnivariateIntegrator

 /**
@ -18,10 +17,10 @@ import org.apache.commons.math3.analysis.integration.UnivariateIntegrator as CMU
 */
 public class CMIntegrator(
    private val defaultMaxCalls: Int = 200,
-    public val integratorBuilder: (Integrand<Float64>) -> CMUnivariateIntegrator,
-) : UnivariateIntegrator<Float64> {
+    public val integratorBuilder: (Integrand<Double>) -> CMUnivariateIntegrator,
+) : UnivariateIntegrator<Double> {

-    override fun integrate(integrand: UnivariateIntegrand<Float64>): UnivariateIntegrand<Float64> {
+    override fun integrate(integrand: UnivariateIntegrand<Double>): UnivariateIntegrand<Double> {
        val integrator = integratorBuilder(integrand)
        val maxCalls = integrand[IntegrandMaxCalls] ?: defaultMaxCalls
        val remainingCalls = maxCalls - integrand.calls
--- a/kmath-commons/src/jvmMain/kotlin/space/kscience/kmath/commons/linear/CMMatrix.kt
+++ b/kmath-commons/src/jvmMain/kotlin/space/kscience/kmath/commons/linear/CMMatrix.kt
@ -12,7 +12,6 @@ import space.kscience.attributes.SafeType
 import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.linear.*
 import space.kscience.kmath.linear.CholeskyDecomposition
-import space.kscience.kmath.linear.EigenDecomposition
 import space.kscience.kmath.linear.QRDecomposition
 import space.kscience.kmath.nd.Structure2D
 import space.kscience.kmath.nd.StructureAttribute
@ -23,7 +22,7 @@ import space.kscience.kmath.structures.Float64
 import space.kscience.kmath.structures.IntBuffer
 import space.kscience.kmath.structures.asBuffer

-public class CMMatrix(public val origin: RealMatrix) : Matrix<Float64> {
+public class CMMatrix(public val origin: RealMatrix) : Matrix<Double> {

    override val rowNum: Int get() = origin.rowDimension
    override val colNum: Int get() = origin.columnDimension
@ -32,12 +31,12 @@ public class CMMatrix(public val origin: RealMatrix) : Matrix<Float64> {
 }

@JvmInline
-public value class CMVector(public val origin: RealVector) : Point<Float64> {
+public value class CMVector(public val origin: RealVector) : Point<Double> {
    override val size: Int get() = origin.dimension

    override operator fun get(index: Int): Double = origin.getEntry(index)

-    override operator fun iterator(): Iterator<Float64> = origin.toArray().iterator()
+    override operator fun iterator(): Iterator<Double> = origin.toArray().iterator()

    override fun toString(): String = Buffer.toString(this)
 }
@ -47,7 +46,7 @@ public fun RealVector.toPoint(): CMVector = CMVector(this)
 public object CMLinearSpace : LinearSpace<Double, Float64Field> {
    override val elementAlgebra: Float64Field get() = Float64Field

-    override val type: SafeType<Float64> get() = DoubleField.type
+    override val type: SafeType<Double> get() = DoubleField.type

    override fun buildMatrix(
        rows: Int,
@ -59,7 +58,7 @@ public object CMLinearSpace : LinearSpace<Double, Float64Field> {
    }

    @OptIn(UnstableKMathAPI::class)
-    public fun Matrix<Float64>.toCM(): CMMatrix = when (val matrix = origin) {
+    public fun Matrix<Double>.toCM(): CMMatrix = when (val matrix = origin) {
        is CMMatrix -> matrix
        else -> {
            //TODO add feature analysis
@ -68,7 +67,7 @@ public object CMLinearSpace : LinearSpace<Double, Float64Field> {
        }
    }

-    public fun Point<Float64>.toCM(): CMVector = if (this is CMVector) this else {
+    public fun Point<Double>.toCM(): CMVector = if (this is CMVector) this else {
        val array = DoubleArray(size) { this[it] }
        ArrayRealVector(array).wrap()
    }
@ -76,41 +75,40 @@ public object CMLinearSpace : LinearSpace<Double, Float64Field> {
    internal fun RealMatrix.wrap(): CMMatrix = CMMatrix(this)
    internal fun RealVector.wrap(): CMVector = CMVector(this)

-    override fun buildVector(size: Int, initializer: Float64Field.(Int) -> Double): Point<Float64> =
+    override fun buildVector(size: Int, initializer: Float64Field.(Int) -> Double): Point<Double> =
        ArrayRealVector(DoubleArray(size) { Float64Field.initializer(it) }).wrap()

-    override fun Matrix<Float64>.plus(other: Matrix<Float64>): CMMatrix =
+    override fun Matrix<Double>.plus(other: Matrix<Double>): CMMatrix =
        toCM().origin.add(other.toCM().origin).wrap()

-    override fun Point<Float64>.plus(other: Point<Float64>): CMVector =
+    override fun Point<Double>.plus(other: Point<Double>): CMVector =
        toCM().origin.add(other.toCM().origin).wrap()

-    override fun Point<Float64>.minus(other: Point<Float64>): CMVector =
+    override fun Point<Double>.minus(other: Point<Double>): CMVector =
        toCM().origin.subtract(other.toCM().origin).wrap()

-    override fun Matrix<Float64>.dot(other: Matrix<Float64>): CMMatrix =
+    override fun Matrix<Double>.dot(other: Matrix<Double>): CMMatrix =
        toCM().origin.multiply(other.toCM().origin).wrap()

-    override fun Matrix<Float64>.dot(vector: Point<Float64>): CMVector =
+    override fun Matrix<Double>.dot(vector: Point<Double>): CMVector =
        toCM().origin.preMultiply(vector.toCM().origin).wrap()

-    override operator fun Matrix<Float64>.minus(other: Matrix<Float64>): CMMatrix =
+    override operator fun Matrix<Double>.minus(other: Matrix<Double>): CMMatrix =
        toCM().origin.subtract(other.toCM().origin).wrap()

-    override operator fun Matrix<Float64>.times(value: Double): CMMatrix =
+    override operator fun Matrix<Double>.times(value: Double): CMMatrix =
        toCM().origin.scalarMultiply(value).wrap()

-    override fun Double.times(m: Matrix<Float64>): CMMatrix =
+    override fun Double.times(m: Matrix<Double>): CMMatrix =
        m * this

-    override fun Point<Float64>.times(value: Double): CMVector =
+    override fun Point<Double>.times(value: Double): CMVector =
        toCM().origin.mapMultiply(value).wrap()

-    override fun Double.times(v: Point<Float64>): CMVector =
+    override fun Double.times(v: Point<Double>): CMVector =
        v * this

-    @OptIn(UnstableKMathAPI::class)
-    override fun <V, A : StructureAttribute<V>> computeAttribute(structure: Structure2D<Float64>, attribute: A): V? {
+    override fun <V, A : StructureAttribute<V>> computeAttribute(structure: Structure2D<Double>, attribute: A): V? {

        val origin = structure.toCM().origin

@ -127,7 +125,7 @@ public object CMLinearSpace : LinearSpace<Double, Float64Field> {

            Cholesky -> object : CholeskyDecomposition<Float64> {
                val cmCholesky by lazy { org.apache.commons.math3.linear.CholeskyDecomposition(origin) }
-                override val l: Matrix<Float64> get() = cmCholesky.l.wrap()
+                override val l: Matrix<Double> get() = cmCholesky.l.wrap()
            }

            QR -> object : QRDecomposition<Float64> {
@ -146,13 +144,6 @@ public object CMLinearSpace : LinearSpace<Double, Float64Field> {

            }

-            EIG -> object : EigenDecomposition<Float64> {
-                val cmEigen by lazy { org.apache.commons.math3.linear.EigenDecomposition(origin) }
-
-                override val v: Matrix<Float64> get() = cmEigen.v.wrap()
-                override val d: Matrix<Float64> get() = cmEigen.d.wrap()
-            }
-
            else -> null
        }
        @Suppress("UNCHECKED_CAST")
--- a/kmath-commons/src/jvmMain/kotlin/space/kscience/kmath/commons/linear/CMSolver.kt
+++ b/kmath-commons/src/jvmMain/kotlin/space/kscience/kmath/commons/linear/CMSolver.kt
@ -9,7 +9,6 @@ import org.apache.commons.math3.linear.*
 import space.kscience.kmath.linear.LinearSolver
 import space.kscience.kmath.linear.Matrix
 import space.kscience.kmath.linear.Point
-import space.kscience.kmath.structures.Float64

 public enum class CMDecomposition {
    LUP,
@ -20,7 +19,7 @@ public enum class CMDecomposition {
 }

 private fun CMLinearSpace.solver(
-    a: Matrix<Float64>,
+    a: Matrix<Double>,
    decomposition: CMDecomposition = CMDecomposition.LUP,
 ): DecompositionSolver = when (decomposition) {
    CMDecomposition.LUP -> LUDecomposition(a.toCM().origin).solver
@ -31,31 +30,31 @@ private fun CMLinearSpace.solver(
 }

 public fun CMLinearSpace.solve(
-    a: Matrix<Float64>,
-    b: Matrix<Float64>,
+    a: Matrix<Double>,
+    b: Matrix<Double>,
    decomposition: CMDecomposition = CMDecomposition.LUP,
 ): CMMatrix = solver(a, decomposition).solve(b.toCM().origin).wrap()

 public fun CMLinearSpace.solve(
-    a: Matrix<Float64>,
-    b: Point<Float64>,
+    a: Matrix<Double>,
+    b: Point<Double>,
    decomposition: CMDecomposition = CMDecomposition.LUP,
 ): CMVector = solver(a, decomposition).solve(b.toCM().origin).toPoint()

 public fun CMLinearSpace.inverse(
-    a: Matrix<Float64>,
+    a: Matrix<Double>,
    decomposition: CMDecomposition = CMDecomposition.LUP,
 ): CMMatrix = solver(a, decomposition).inverse.wrap()


-public fun CMLinearSpace.solver(decomposition: CMDecomposition): LinearSolver<Float64> = object : LinearSolver<Float64> {
-    override fun solve(a: Matrix<Float64>, b: Matrix<Float64>): Matrix<Float64> =
+public fun CMLinearSpace.solver(decomposition: CMDecomposition): LinearSolver<Double> = object : LinearSolver<Double> {
+    override fun solve(a: Matrix<Double>, b: Matrix<Double>): Matrix<Double> =
        solver(a, decomposition).solve(b.toCM().origin).wrap()

-    override fun solve(a: Matrix<Float64>, b: Point<Float64>): Point<Float64> =
+    override fun solve(a: Matrix<Double>, b: Point<Double>): Point<Double> =
        solver(a, decomposition).solve(b.toCM().origin).toPoint()

-    override fun inverse(matrix: Matrix<Float64>): Matrix<Float64> = solver(matrix, decomposition).inverse.wrap()
+    override fun inverse(matrix: Matrix<Double>): Matrix<Double> = solver(matrix, decomposition).inverse.wrap()
 }

-public fun CMLinearSpace.lupSolver(): LinearSolver<Float64> = solver((CMDecomposition.LUP))
+public fun CMLinearSpace.lupSolver(): LinearSolver<Double> = solver((CMDecomposition.LUP))
--- a/kmath-commons/src/jvmMain/kotlin/space/kscience/kmath/commons/optimization/CMOptimizer.kt
+++ b/kmath-commons/src/jvmMain/kotlin/space/kscience/kmath/commons/optimization/CMOptimizer.kt
@ -22,7 +22,6 @@ import space.kscience.kmath.expressions.SymbolIndexer
 import space.kscience.kmath.expressions.derivative
 import space.kscience.kmath.expressions.withSymbols
 import space.kscience.kmath.optimization.*
-import space.kscience.kmath.structures.Float64
 import kotlin.collections.set
 import kotlin.reflect.KClass

@ -34,7 +33,7 @@ public object CMOptimizerEngine : OptimizationAttribute<() -> MultivariateOptimi
 /**
 * Specify a Commons-maths optimization engine
 */
-public fun AttributesBuilder<FunctionOptimization<Float64>>.cmEngine(optimizerBuilder: () -> MultivariateOptimizer) {
+public fun AttributesBuilder<FunctionOptimization<Double>>.cmEngine(optimizerBuilder: () -> MultivariateOptimizer) {
    set(CMOptimizerEngine, optimizerBuilder)
 }

@ -43,18 +42,18 @@ public object CMOptimizerData : SetAttribute<SymbolIndexer.() -> OptimizationDat
 /**
 * Specify Commons-maths optimization data.
 */
-public fun AttributesBuilder<FunctionOptimization<Float64>>.cmOptimizationData(data: SymbolIndexer.() -> OptimizationData) {
+public fun AttributesBuilder<FunctionOptimization<Double>>.cmOptimizationData(data: SymbolIndexer.() -> OptimizationData) {
    CMOptimizerData add data
 }

-public fun AttributesBuilder<FunctionOptimization<Float64>>.simplexSteps(vararg steps: Pair<Symbol, Double>) {
+public fun AttributesBuilder<FunctionOptimization<Double>>.simplexSteps(vararg steps: Pair<Symbol, Double>) {
    //TODO use convergence checker from features
    cmEngine { SimplexOptimizer(CMOptimizer.defaultConvergenceChecker) }
    cmOptimizationData { NelderMeadSimplex(mapOf(*steps).toDoubleArray()) }
 }

@OptIn(UnstableKMathAPI::class)
-public object CMOptimizer : Optimizer<Double, FunctionOptimization<Float64>> {
+public object CMOptimizer : Optimizer<Double, FunctionOptimization<Double>> {

    public const val DEFAULT_RELATIVE_TOLERANCE: Double = 1e-4
    public const val DEFAULT_ABSOLUTE_TOLERANCE: Double = 1e-4
@ -68,12 +67,12 @@ public object CMOptimizer : Optimizer<Double, FunctionOptimization<Float64>> {


    override suspend fun optimize(
-        problem: FunctionOptimization<Float64>,
-    ): FunctionOptimization<Float64> {
+        problem: FunctionOptimization<Double>,
+    ): FunctionOptimization<Double> {
        val startPoint = problem.startPoint

        val parameters = problem.attributes[OptimizationParameters]
-            ?: problem.attributes[OptimizationStartPoint<Float64>()]?.keys
+            ?: problem.attributes[OptimizationStartPoint<Double>()]?.keys
            ?: startPoint.keys


--- a/kmath-commons/src/jvmMain/kotlin/space/kscience/kmath/commons/transform/Transformations.kt
+++ b/kmath-commons/src/jvmMain/kotlin/space/kscience/kmath/commons/transform/Transformations.kt
@ -77,7 +77,7 @@ public fun Flow<Buffer<Complex>>.fft(
 }

@JvmName("realFFT")
-public fun Flow<Buffer<Float64>>.fft(
+public fun Flow<Buffer<Double>>.fft(
    normalization: DftNormalization = DftNormalization.STANDARD,
    direction: TransformType = TransformType.FORWARD,
 ): Flow<Buffer<Complex>> {
@ -89,7 +89,7 @@ public fun Flow<Buffer<Float64>>.fft(
 * Process a continuous flow of real numbers in FFT splitting it in chunks of [bufferSize].
 */
@JvmName("realFFT")
-public fun Flow<Float64>.fft(
+public fun Flow<Double>.fft(
    bufferSize: Int = Int.MAX_VALUE,
    normalization: DftNormalization = DftNormalization.STANDARD,
    direction: TransformType = TransformType.FORWARD,
@ -99,4 +99,4 @@ public fun Flow<Float64>.fft(
 * Map a complex flow into real flow by taking real part of each number
 */
@FlowPreview
-public fun Flow<Complex>.real(): Flow<Float64> = map { it.re }
+public fun Flow<Complex>.real(): Flow<Double> = map { it.re }
--- a/kmath-commons/src/jvmTest/kotlin/space/kscience/kmath/commons/optimization/OptimizeTest.kt
+++ b/kmath-commons/src/jvmTest/kotlin/space/kscience/kmath/commons/optimization/OptimizeTest.kt
@ -18,7 +18,6 @@ import space.kscience.kmath.operations.Float64Field
 import space.kscience.kmath.optimization.*
 import space.kscience.kmath.random.RandomGenerator
 import space.kscience.kmath.stat.chiSquaredExpression
-import space.kscience.kmath.structures.Float64
 import space.kscience.kmath.structures.Float64Buffer
 import space.kscience.kmath.structures.asBuffer
 import kotlin.test.Test
@ -71,7 +70,7 @@ internal class OptimizeTest {
            bindSymbol(a) * arg.pow(2) + bindSymbol(b) * arg + cWithDefault
        }

-        val result: FunctionOptimization<Float64> = chi2.optimizeWith(
+        val result: FunctionOptimization<Double> = chi2.optimizeWith(
            CMOptimizer,
            mapOf(a to 1.5, b to 0.9, c to 1.0),
        ) {
--- a/kmath-complex/src/commonMain/kotlin/space/kscience/kmath/complex/Quaternion.kt
+++ b/kmath-complex/src/commonMain/kotlin/space/kscience/kmath/complex/Quaternion.kt
@ -11,7 +11,6 @@ import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.memory.*
 import space.kscience.kmath.operations.*
 import space.kscience.kmath.structures.Buffer
-import space.kscience.kmath.structures.Float64
 import space.kscience.kmath.structures.MutableBuffer
 import space.kscience.kmath.structures.MutableBufferFactory
 import kotlin.math.*
@ -29,7 +28,7 @@ public class Quaternion(
    public val x: Double,
    public val y: Double,
    public val z: Double,
-) : Buffer<Float64> {
+) : Buffer<Double> {
    init {
        require(!w.isNaN()) { "w-component of quaternion is not-a-number" }
        require(!x.isNaN()) { "x-component of quaternion is not-a-number" }
@ -52,7 +51,7 @@ public class Quaternion(
        else -> error("Index $index out of bounds [0,3]")
    }

-    override fun iterator(): Iterator<Float64> = listOf(w, x, y, z).iterator()
+    override fun iterator(): Iterator<Double> = listOf(w, x, y, z).iterator()

    override fun equals(other: Any?): Boolean {
        if (this === other) return true
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/Domain1D.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/Domain1D.kt
@ -7,7 +7,6 @@ package space.kscience.kmath.domains

 import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.linear.Point
-import space.kscience.kmath.structures.Float64

@UnstableKMathAPI
 public abstract class Domain1D<T : Comparable<T>>(public val range: ClosedRange<T>) : Domain<T> {
@ -23,8 +22,8 @@ public abstract class Domain1D<T : Comparable<T>>(public val range: ClosedRange<

@UnstableKMathAPI
 public class DoubleDomain1D(
-    @Suppress("CanBeParameter") public val doubleRange: ClosedFloatingPointRange<Float64>,
-) : Domain1D<Float64>(doubleRange), Float64Domain {
+    @Suppress("CanBeParameter") public val doubleRange: ClosedFloatingPointRange<Double>,
+) : Domain1D<Double>(doubleRange), Float64Domain {
    override fun getLowerBound(num: Int): Double {
        require(num == 0)
        return range.start
@ -56,5 +55,5 @@ public class DoubleDomain1D(
 }

@UnstableKMathAPI
-public val Domain1D<Float64>.center: Double
+public val Domain1D<Double>.center: Double
    get() = (range.endInclusive + range.start) / 2
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/Float64Domain.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/Float64Domain.kt
@ -5,7 +5,6 @@
 package space.kscience.kmath.domains

 import space.kscience.kmath.UnstableKMathAPI
-import space.kscience.kmath.structures.Float64

 /**
 * n-dimensional volume
@ -13,7 +12,7 @@ import space.kscience.kmath.structures.Float64
 * @author Alexander Nozik
 */
@UnstableKMathAPI
-public interface Float64Domain : Domain<Float64> {
+public interface Float64Domain : Domain<Double> {
    /**
     * Global lower edge
     * @param num axis number
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/HyperSquareDomain.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/HyperSquareDomain.kt
@ -7,7 +7,6 @@ package space.kscience.kmath.domains
 import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.linear.Point
 import space.kscience.kmath.structures.Buffer
-import space.kscience.kmath.structures.Float64
 import space.kscience.kmath.structures.Float64Buffer
 import space.kscience.kmath.structures.indices

@ -16,7 +15,7 @@ import space.kscience.kmath.structures.indices
 * and a [Buffer] of upper boundaries. Upper should be greater or equals than lower.
 */
@UnstableKMathAPI
-public class HyperSquareDomain(public val lower: Buffer<Float64>, public val upper: Buffer<Float64>) : Float64Domain {
+public class HyperSquareDomain(public val lower: Buffer<Double>, public val upper: Buffer<Double>) : Float64Domain {
    init {
        require(lower.size == upper.size) {
            "Domain borders size mismatch. Lower borders size is ${lower.size}, but upper borders size is ${upper.size}."
@ -30,7 +29,7 @@ public class HyperSquareDomain(public val lower: Buffer<Float64>, public val upp

    public val center: Float64Buffer get() = Float64Buffer(dimension) { (lower[it] + upper[it]) / 2.0 }

-    override operator fun contains(point: Point<Float64>): Boolean = point.indices.all { i ->
+    override operator fun contains(point: Point<Double>): Boolean = point.indices.all { i ->
        point[i] in lower[i]..upper[i]
    }

--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/UnconstrainedDomain.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/UnconstrainedDomain.kt
@ -6,11 +6,10 @@ package space.kscience.kmath.domains

 import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.linear.Point
-import space.kscience.kmath.structures.Float64

@UnstableKMathAPI
 public class UnconstrainedDomain(override val dimension: Int) : Float64Domain {
-    override operator fun contains(point: Point<Float64>): Boolean = true
+    override operator fun contains(point: Point<Double>): Boolean = true

    override fun getLowerBound(num: Int): Double = Double.NEGATIVE_INFINITY

--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/Expression.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/Expression.kt
@ -13,7 +13,6 @@ import space.kscience.kmath.operations.Algebra
 import space.kscience.kmath.operations.DoubleField
 import space.kscience.kmath.operations.IntRing
 import space.kscience.kmath.operations.LongRing
-import space.kscience.kmath.structures.Float64
 import kotlin.jvm.JvmName
 import kotlin.properties.ReadOnlyProperty

@ -48,9 +47,9 @@ public inline fun <reified T> Expression(noinline block: (Map<Symbol, T>) -> T):
 * Specialization of [Expression] for [Double] allowing better performance because of using array.
 */
@UnstableKMathAPI
-public interface DoubleExpression : Expression<Float64> {
+public interface DoubleExpression : Expression<Double> {

-    override val type: SafeType<Float64> get() = DoubleField.type
+    override val type: SafeType<Double> get() = DoubleField.type

    /**
     * The indexer of this expression's arguments that should be used to build array for [invoke].
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/FunctionalExpressionAlgebra.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/FunctionalExpressionAlgebra.kt
@ -6,7 +6,6 @@
 package space.kscience.kmath.expressions

 import space.kscience.kmath.operations.*
-import space.kscience.kmath.structures.Float64
 import space.kscience.kmath.structures.MutableBufferFactory
 import kotlin.contracts.InvocationKind
 import kotlin.contracts.contract
@ -198,5 +197,5 @@ public inline fun <T, A : ExtendedField<T>> A.expressionInExtendedField(
 ): Expression<T> = FunctionalExpressionExtendedField(this).block()

 public inline fun Float64Field.expression(
-    block: FunctionalExpressionExtendedField<Double, Float64Field>.() -> Expression<Float64>,
-): Expression<Float64> = FunctionalExpressionExtendedField(this).block()
+    block: FunctionalExpressionExtendedField<Double, Float64Field>.() -> Expression<Double>,
+): Expression<Double> = FunctionalExpressionExtendedField(this).block()
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/EigenDecomposition.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/EigenDecomposition.kt
@ -1,32 +0,0 @@
-/*
- * Copyright 2018-2024 KMath contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package space.kscience.kmath.linear
-
-import space.kscience.attributes.PolymorphicAttribute
-import space.kscience.attributes.safeTypeOf
-import space.kscience.kmath.UnstableKMathAPI
-
-@UnstableKMathAPI
-public interface EigenDecomposition<T> {
-    /**
-     * Eigenvector matrix.
-     */
-    public val v: Matrix<T>
-
-    /**
-     * A diagonal matrix of eigenvalues. Must have [IsDiagonal]
-     */
-    public val d: Matrix<T>
-}
-
-@UnstableKMathAPI
-public class EigenDecompositionAttribute<T> :
-    PolymorphicAttribute<EigenDecomposition<T>>(safeTypeOf()),
-    MatrixAttribute<EigenDecomposition<T>>
-
-@UnstableKMathAPI
-public val <T> MatrixScope<T>.EIG: EigenDecompositionAttribute<T>
-    get() = EigenDecompositionAttribute()
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/Float64LinearSpace.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/Float64LinearSpace.kt
@ -6,19 +6,12 @@
 package space.kscience.kmath.linear

 import space.kscience.kmath.PerformancePitfall
-import space.kscience.kmath.nd.Floa64FieldOpsND
-import space.kscience.kmath.nd.ShapeND
-import space.kscience.kmath.nd.as2D
-import space.kscience.kmath.nd.asND
+import space.kscience.kmath.nd.*
 import space.kscience.kmath.operations.Float64BufferOps
 import space.kscience.kmath.operations.Float64Field
 import space.kscience.kmath.operations.invoke
 import space.kscience.kmath.structures.Buffer
-import space.kscience.kmath.structures.Float64
 import space.kscience.kmath.structures.Float64Buffer
-import kotlin.collections.component1
-import kotlin.collections.component2
-import kotlin.collections.map

 public object Float64LinearSpace : LinearSpace<Double, Float64Field> {

@ -28,36 +21,36 @@ public object Float64LinearSpace : LinearSpace<Double, Float64Field> {
        rows: Int,
        columns: Int,
        initializer: Float64Field.(i: Int, j: Int) -> Double,
-    ): Matrix<Float64> = Floa64FieldOpsND.structureND(ShapeND(rows, columns)) { (i, j) ->
+    ): Matrix<Double> = Floa64FieldOpsND.structureND(ShapeND(rows, columns)) { (i, j) ->
        Float64Field.initializer(i, j)
    }.as2D()

    override fun buildVector(size: Int, initializer: Float64Field.(Int) -> Double): Float64Buffer =
        Float64Buffer(size) { Float64Field.initializer(it) }

-    override fun Matrix<Float64>.unaryMinus(): Matrix<Float64> = Floa64FieldOpsND {
+    override fun Matrix<Double>.unaryMinus(): Matrix<Double> = Floa64FieldOpsND {
        asND().map { -it }.as2D()
    }

-    override fun Matrix<Float64>.plus(other: Matrix<Float64>): Matrix<Float64> = Floa64FieldOpsND {
+    override fun Matrix<Double>.plus(other: Matrix<Double>): Matrix<Double> = Floa64FieldOpsND {
        require(shape == other.shape) { "Shape mismatch on Matrix::plus. Expected $shape but found ${other.shape}" }
        asND().plus(other.asND()).as2D()
    }

-    override fun Matrix<Float64>.minus(other: Matrix<Float64>): Matrix<Float64> = Floa64FieldOpsND {
+    override fun Matrix<Double>.minus(other: Matrix<Double>): Matrix<Double> = Floa64FieldOpsND {
        require(shape == other.shape) { "Shape mismatch on Matrix::minus. Expected $shape but found ${other.shape}" }
        asND().minus(other.asND()).as2D()
    }

    // Create a continuous in-memory representation of this vector for better memory layout handling
-    private fun Buffer<Float64>.linearize() = if (this is Float64Buffer) {
+    private fun Buffer<Double>.linearize() = if (this is Float64Buffer) {
        this.array
    } else {
        DoubleArray(size) { get(it) }
    }

    @OptIn(PerformancePitfall::class)
-    override fun Matrix<Float64>.dot(other: Matrix<Float64>): Matrix<Float64> {
+    override fun Matrix<Double>.dot(other: Matrix<Double>): Matrix<Double> {
        require(colNum == other.rowNum) { "Matrix dot operation dimension mismatch: ($rowNum, $colNum) x (${other.rowNum}, ${other.colNum})" }
        val rows = this@dot.rows.map { it.linearize() }
        val columns = other.columns.map { it.linearize() }
@ -74,7 +67,7 @@ public object Float64LinearSpace : LinearSpace<Double, Float64Field> {
    }

    @OptIn(PerformancePitfall::class)
-    override fun Matrix<Float64>.dot(vector: Point<Float64>): Float64Buffer {
+    override fun Matrix<Double>.dot(vector: Point<Double>): Float64Buffer {
        require(colNum == vector.size) { "Matrix dot vector operation dimension mismatch: ($rowNum, $colNum) x (${vector.size})" }
        val rows = this@dot.rows.map { it.linearize() }
        val indices = 0 until this.colNum
@ -89,27 +82,27 @@ public object Float64LinearSpace : LinearSpace<Double, Float64Field> {

    }

-    override fun Matrix<Float64>.times(value: Double): Matrix<Float64> = Floa64FieldOpsND {
+    override fun Matrix<Double>.times(value: Double): Matrix<Double> = Floa64FieldOpsND {
        asND().map { it * value }.as2D()
    }

-    public override fun Point<Float64>.plus(other: Point<Float64>): Float64Buffer = Float64BufferOps.run {
+    public override fun Point<Double>.plus(other: Point<Double>): Float64Buffer = Float64BufferOps.run {
        this@plus + other
    }

-    public override fun Point<Float64>.minus(other: Point<Float64>): Float64Buffer = Float64BufferOps.run {
+    public override fun Point<Double>.minus(other: Point<Double>): Float64Buffer = Float64BufferOps.run {
        this@minus - other
    }

-    public override fun Point<Float64>.times(value: Double): Float64Buffer = Float64BufferOps.run {
+    public override fun Point<Double>.times(value: Double): Float64Buffer = Float64BufferOps.run {
        scale(this@times, value)
    }

-    public operator fun Point<Float64>.div(value: Double): Float64Buffer = Float64BufferOps.run {
+    public operator fun Point<Double>.div(value: Double): Float64Buffer = Float64BufferOps.run {
        scale(this@div, 1.0 / value)
    }

-    public override fun Double.times(v: Point<Float64>): Float64Buffer = v * this
+    public override fun Double.times(v: Point<Double>): Float64Buffer = v * this


 }
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LupDecomposition.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LupDecomposition.kt
@ -163,9 +163,9 @@ public fun <T : Comparable<T>> Field<T>.lup(


 public fun Field<Float64>.lup(
-    matrix: Matrix<Float64>,
+    matrix: Matrix<Double>,
    singularityThreshold: Double = 1e-11,
-): GenericLupDecomposition<Float64> = lup(matrix) { it < singularityThreshold }
+): GenericLupDecomposition<Double> = lup(matrix) { it < singularityThreshold }

 private fun <T> Field<T>.solve(
    lup: LupDecomposition<T>,
@ -235,5 +235,5 @@ public fun <T : Comparable<T>> LinearSpace<T, Field<T>>.lupSolver(
    override fun inverse(matrix: Matrix<T>): Matrix<T> = solve(matrix, one(matrix.rowNum, matrix.colNum))
 }

-public fun LinearSpace<Double, Float64Field>.lupSolver(singularityThreshold: Double = 1e-11): LinearSolver<Float64> =
+public fun LinearSpace<Double, Float64Field>.lupSolver(singularityThreshold: Double = 1e-11): LinearSolver<Double> =
    lupSolver { it < singularityThreshold }
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixBuilder.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixBuilder.kt
@ -67,14 +67,13 @@ public fun <T : Any, A : Ring<T>> MatrixBuilder<T, A>.symmetric(
 ): Matrix<T> {
    require(columns == rows) { "In order to build symmetric matrix, number of rows $rows should be equal to number of columns $columns" }
    return with(BufferAccessor2D<T?>(rows, rows, MutableBufferFactory(type))) {
-        val cache = HashMap<IntArray, T>()
+        val cache = factory(rows * rows) { null }
        linearSpace.buildMatrix(rows, rows) { i, j ->
-            val index = intArrayOf(i, j)
-            val cached = cache[index]
+            val cached = cache[i, j]
            if (cached == null) {
                val value = if (i <= j) builder(i, j) else builder(j, i)
-                cache[index] = value
-                cache[index] = value
+                cache[i, j] = value
+                cache[j, i] = value
                value
            } else {
                cached
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/misc/cumulative.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/misc/cumulative.kt
@ -8,7 +8,6 @@ package space.kscience.kmath.misc
 import space.kscience.kmath.operations.Ring
 import space.kscience.kmath.operations.invoke
 import space.kscience.kmath.structures.Buffer
-import space.kscience.kmath.structures.Float64
 import kotlin.jvm.JvmName

 /**
@ -48,7 +47,7 @@ public fun <T> Iterable<T>.cumulativeSum(ring: Ring<T>): Iterable<T> =
    ring { cumulative(zero) { element: T, sum: T -> sum + element } }

@JvmName("cumulativeSumOfDouble")
-public fun Iterable<Float64>.cumulativeSum(): Iterable<Float64> = cumulative(0.0) { element, sum -> sum + element }
+public fun Iterable<Double>.cumulativeSum(): Iterable<Double> = cumulative(0.0) { element, sum -> sum + element }

@JvmName("cumulativeSumOfInt")
 public fun Iterable<Int>.cumulativeSum(): Iterable<Int> = cumulative(0) { element, sum -> sum + element }
@ -60,7 +59,7 @@ public fun <T> Sequence<T>.cumulativeSum(ring: Ring<T>): Sequence<T> =
    ring { cumulative(zero) { element: T, sum: T -> sum + element } }

@JvmName("cumulativeSumOfDouble")
-public fun Sequence<Float64>.cumulativeSum(): Sequence<Float64> = cumulative(0.0) { element, sum -> sum + element }
+public fun Sequence<Double>.cumulativeSum(): Sequence<Double> = cumulative(0.0) { element, sum -> sum + element }

@JvmName("cumulativeSumOfInt")
 public fun Sequence<Int>.cumulativeSum(): Sequence<Int> = cumulative(0) { element, sum -> sum + element }
@ -72,7 +71,7 @@ public fun <T> List<T>.cumulativeSum(group: Ring<T>): List<T> =
    group { cumulative(zero) { element: T, sum: T -> sum + element } }

@JvmName("cumulativeSumOfDouble")
-public fun List<Float64>.cumulativeSum(): List<Float64> = cumulative(0.0) { element, sum -> sum + element }
+public fun List<Double>.cumulativeSum(): List<Double> = cumulative(0.0) { element, sum -> sum + element }

@JvmName("cumulativeSumOfInt")
 public fun List<Int>.cumulativeSum(): List<Int> = cumulative(0) { element, sum -> sum + element }
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/Float64FieldND.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/Float64FieldND.kt
@ -8,7 +8,6 @@ package space.kscience.kmath.nd
 import space.kscience.kmath.PerformancePitfall
 import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.operations.*
-import space.kscience.kmath.structures.Float64
 import space.kscience.kmath.structures.Float64Buffer
 import kotlin.contracts.InvocationKind
 import kotlin.contracts.contract
@ -21,7 +20,7 @@ import kotlin.math.pow as kpow
 public class Float64BufferND(
    indexes: ShapeIndexer,
    override val buffer: Float64Buffer,
-) : MutableBufferND<Float64>(indexes, buffer), MutableStructureNDOfDouble {
+) : MutableBufferND<Double>(indexes, buffer), MutableStructureNDOfDouble {

    override fun getDouble(index: IntArray): Double = buffer[indices.offset(index)]

@ -31,11 +30,11 @@ public class Float64BufferND(
 }


-public sealed class Floa64FieldOpsND : BufferedFieldOpsND<Float64, Float64Field>(Float64Field.bufferAlgebra),
-    ScaleOperations<StructureND<Float64>>, ExtendedFieldOps<StructureND<Float64>> {
+public sealed class Floa64FieldOpsND : BufferedFieldOpsND<Double, Float64Field>(Float64Field.bufferAlgebra),
+    ScaleOperations<StructureND<Double>>, ExtendedFieldOps<StructureND<Double>> {

    @OptIn(PerformancePitfall::class)
-    override fun StructureND<Float64>.toBufferND(): Float64BufferND = when (this) {
+    override fun StructureND<Double>.toBufferND(): Float64BufferND = when (this) {
        is Float64BufferND -> this
        else -> {
            val indexer = indexerBuilder(shape)
@ -65,16 +64,16 @@ public sealed class Floa64FieldOpsND : BufferedFieldOpsND<Float64, Float64Field>
    }

    @OptIn(PerformancePitfall::class)
-    override fun StructureND<Float64>.map(transform: Float64Field.(Double) -> Double): BufferND<Float64> =
+    override fun StructureND<Double>.map(transform: Float64Field.(Double) -> Double): BufferND<Double> =
        mapInline(toBufferND()) { Float64Field.transform(it) }


    @OptIn(PerformancePitfall::class)
    override fun zip(
-        left: StructureND<Float64>,
-        right: StructureND<Float64>,
+        left: StructureND<Double>,
+        right: StructureND<Double>,
        transform: Float64Field.(Double, Double) -> Double,
-    ): BufferND<Float64> = zipInline(left.toBufferND(), right.toBufferND()) { l, r -> Float64Field.transform(l, r) }
+    ): BufferND<Double> = zipInline(left.toBufferND(), right.toBufferND()) { l, r -> Float64Field.transform(l, r) }

    override fun mutableStructureND(shape: ShapeND, initializer: Float64Field.(IntArray) -> Double): Float64BufferND {
        val indexer = indexerBuilder(shape)
@ -86,102 +85,102 @@ public sealed class Floa64FieldOpsND : BufferedFieldOpsND<Float64, Float64Field>
        )
    }

-    override fun add(left: StructureND<Float64>, right: StructureND<Float64>): Float64BufferND =
+    override fun add(left: StructureND<Double>, right: StructureND<Double>): Float64BufferND =
        zipInline(left.toBufferND(), right.toBufferND()) { l, r -> l + r }

-    override fun multiply(left: StructureND<Float64>, right: StructureND<Float64>): Float64BufferND =
+    override fun multiply(left: StructureND<Double>, right: StructureND<Double>): Float64BufferND =
        zipInline(left.toBufferND(), right.toBufferND()) { l, r -> l * r }

-    override fun StructureND<Float64>.unaryMinus(): Float64BufferND = mapInline(toBufferND()) { -it }
+    override fun StructureND<Double>.unaryMinus(): Float64BufferND = mapInline(toBufferND()) { -it }

-    override fun StructureND<Float64>.div(arg: StructureND<Float64>): Float64BufferND =
+    override fun StructureND<Double>.div(arg: StructureND<Double>): Float64BufferND =
        zipInline(toBufferND(), arg.toBufferND()) { l, r -> l / r }

-    override fun divide(left: StructureND<Float64>, right: StructureND<Float64>): Float64BufferND =
+    override fun divide(left: StructureND<Double>, right: StructureND<Double>): Float64BufferND =
        zipInline(left.toBufferND(), right.toBufferND()) { l: Double, r: Double -> l / r }

-    override fun StructureND<Float64>.div(arg: Double): Float64BufferND =
+    override fun StructureND<Double>.div(arg: Double): Float64BufferND =
        mapInline(toBufferND()) { it / arg }

-    override fun Double.div(arg: StructureND<Float64>): Float64BufferND =
+    override fun Double.div(arg: StructureND<Double>): Float64BufferND =
        mapInline(arg.toBufferND()) { this / it }

-    override fun StructureND<Float64>.unaryPlus(): Float64BufferND = toBufferND()
+    override fun StructureND<Double>.unaryPlus(): Float64BufferND = toBufferND()

-    override fun StructureND<Float64>.plus(arg: StructureND<Float64>): Float64BufferND =
+    override fun StructureND<Double>.plus(arg: StructureND<Double>): Float64BufferND =
        zipInline(toBufferND(), arg.toBufferND()) { l: Double, r: Double -> l + r }

-    override fun StructureND<Float64>.minus(arg: StructureND<Float64>): Float64BufferND =
+    override fun StructureND<Double>.minus(arg: StructureND<Double>): Float64BufferND =
        zipInline(toBufferND(), arg.toBufferND()) { l: Double, r: Double -> l - r }

-    override fun StructureND<Float64>.times(arg: StructureND<Float64>): Float64BufferND =
+    override fun StructureND<Double>.times(arg: StructureND<Double>): Float64BufferND =
        zipInline(toBufferND(), arg.toBufferND()) { l: Double, r: Double -> l * r }

-    override fun StructureND<Float64>.times(k: Number): Float64BufferND =
+    override fun StructureND<Double>.times(k: Number): Float64BufferND =
        mapInline(toBufferND()) { it * k.toDouble() }

-    override fun StructureND<Float64>.div(k: Number): Float64BufferND =
+    override fun StructureND<Double>.div(k: Number): Float64BufferND =
        mapInline(toBufferND()) { it / k.toDouble() }

-    override fun Number.times(arg: StructureND<Float64>): Float64BufferND = arg * this
+    override fun Number.times(arg: StructureND<Double>): Float64BufferND = arg * this

-    override fun StructureND<Float64>.plus(arg: Double): Float64BufferND = mapInline(toBufferND()) { it + arg }
+    override fun StructureND<Double>.plus(arg: Double): Float64BufferND = mapInline(toBufferND()) { it + arg }

-    override fun StructureND<Float64>.minus(arg: Double): StructureND<Float64> = mapInline(toBufferND()) { it - arg }
+    override fun StructureND<Double>.minus(arg: Double): StructureND<Double> = mapInline(toBufferND()) { it - arg }

-    override fun Double.plus(arg: StructureND<Float64>): StructureND<Float64> = arg + this
+    override fun Double.plus(arg: StructureND<Double>): StructureND<Double> = arg + this

-    override fun Double.minus(arg: StructureND<Float64>): StructureND<Float64> = mapInline(arg.toBufferND()) { this - it }
+    override fun Double.minus(arg: StructureND<Double>): StructureND<Double> = mapInline(arg.toBufferND()) { this - it }

-    override fun scale(a: StructureND<Float64>, value: Double): Float64BufferND =
+    override fun scale(a: StructureND<Double>, value: Double): Float64BufferND =
        mapInline(a.toBufferND()) { it * value }

-    override fun exp(arg: StructureND<Float64>): Float64BufferND =
+    override fun exp(arg: StructureND<Double>): Float64BufferND =
        mapInline(arg.toBufferND()) { kotlin.math.exp(it) }

-    override fun ln(arg: StructureND<Float64>): Float64BufferND =
+    override fun ln(arg: StructureND<Double>): Float64BufferND =
        mapInline(arg.toBufferND()) { kotlin.math.ln(it) }

-    override fun sin(arg: StructureND<Float64>): Float64BufferND =
+    override fun sin(arg: StructureND<Double>): Float64BufferND =
        mapInline(arg.toBufferND()) { kotlin.math.sin(it) }

-    override fun cos(arg: StructureND<Float64>): Float64BufferND =
+    override fun cos(arg: StructureND<Double>): Float64BufferND =
        mapInline(arg.toBufferND()) { kotlin.math.cos(it) }

-    override fun tan(arg: StructureND<Float64>): Float64BufferND =
+    override fun tan(arg: StructureND<Double>): Float64BufferND =
        mapInline(arg.toBufferND()) { kotlin.math.tan(it) }

-    override fun asin(arg: StructureND<Float64>): Float64BufferND =
+    override fun asin(arg: StructureND<Double>): Float64BufferND =
        mapInline(arg.toBufferND()) { kotlin.math.asin(it) }

-    override fun acos(arg: StructureND<Float64>): Float64BufferND =
+    override fun acos(arg: StructureND<Double>): Float64BufferND =
        mapInline(arg.toBufferND()) { kotlin.math.acos(it) }

-    override fun atan(arg: StructureND<Float64>): Float64BufferND =
+    override fun atan(arg: StructureND<Double>): Float64BufferND =
        mapInline(arg.toBufferND()) { kotlin.math.atan(it) }

-    override fun sinh(arg: StructureND<Float64>): Float64BufferND =
+    override fun sinh(arg: StructureND<Double>): Float64BufferND =
        mapInline(arg.toBufferND()) { kotlin.math.sinh(it) }

-    override fun cosh(arg: StructureND<Float64>): Float64BufferND =
+    override fun cosh(arg: StructureND<Double>): Float64BufferND =
        mapInline(arg.toBufferND()) { kotlin.math.cosh(it) }

-    override fun tanh(arg: StructureND<Float64>): Float64BufferND =
+    override fun tanh(arg: StructureND<Double>): Float64BufferND =
        mapInline(arg.toBufferND()) { kotlin.math.tanh(it) }

-    override fun asinh(arg: StructureND<Float64>): Float64BufferND =
+    override fun asinh(arg: StructureND<Double>): Float64BufferND =
        mapInline(arg.toBufferND()) { kotlin.math.asinh(it) }

-    override fun acosh(arg: StructureND<Float64>): Float64BufferND =
+    override fun acosh(arg: StructureND<Double>): Float64BufferND =
        mapInline(arg.toBufferND()) { kotlin.math.acosh(it) }

-    override fun atanh(arg: StructureND<Float64>): Float64BufferND =
+    override fun atanh(arg: StructureND<Double>): Float64BufferND =
        mapInline(arg.toBufferND()) { kotlin.math.atanh(it) }

    override fun power(
-        arg: StructureND<Float64>,
+        arg: StructureND<Double>,
        pow: Number,
-    ): StructureND<Float64> = if (pow is Int) {
+    ): StructureND<Double> = if (pow is Int) {
        mapInline(arg.toBufferND()) { it.pow(pow) }
    } else {
        mapInline(arg.toBufferND()) { it.pow(pow.toDouble()) }
@ -192,18 +191,18 @@ public sealed class Floa64FieldOpsND : BufferedFieldOpsND<Float64, Float64Field>

@OptIn(UnstableKMathAPI::class)
 public class Float64FieldND(override val shape: ShapeND) :
-    Floa64FieldOpsND(), FieldND<Double, Float64Field>, NumbersAddOps<StructureND<Float64>>,
-    ExtendedField<StructureND<Float64>> {
+    Floa64FieldOpsND(), FieldND<Double, Float64Field>, NumbersAddOps<StructureND<Double>>,
+    ExtendedField<StructureND<Double>> {

-    override fun power(arg: StructureND<Float64>, pow: UInt): Float64BufferND = mapInline(arg.toBufferND()) {
+    override fun power(arg: StructureND<Double>, pow: UInt): Float64BufferND = mapInline(arg.toBufferND()) {
        it.kpow(pow.toInt())
    }

-    override fun power(arg: StructureND<Float64>, pow: Int): Float64BufferND = mapInline(arg.toBufferND()) {
+    override fun power(arg: StructureND<Double>, pow: Int): Float64BufferND = mapInline(arg.toBufferND()) {
        it.kpow(pow)
    }

-    override fun power(arg: StructureND<Float64>, pow: Number): Float64BufferND = if (pow.isInteger()) {
+    override fun power(arg: StructureND<Double>, pow: Number): Float64BufferND = if (pow.isInteger()) {
        power(arg, pow.toInt())
    } else {
        val dpow = pow.toDouble()
@ -213,17 +212,17 @@ public class Float64FieldND(override val shape: ShapeND) :
        }
    }

-    override fun sinh(arg: StructureND<Float64>): Float64BufferND = super<Floa64FieldOpsND>.sinh(arg)
+    override fun sinh(arg: StructureND<Double>): Float64BufferND = super<Floa64FieldOpsND>.sinh(arg)

-    override fun cosh(arg: StructureND<Float64>): Float64BufferND = super<Floa64FieldOpsND>.cosh(arg)
+    override fun cosh(arg: StructureND<Double>): Float64BufferND = super<Floa64FieldOpsND>.cosh(arg)

-    override fun tanh(arg: StructureND<Float64>): Float64BufferND = super<Floa64FieldOpsND>.tan(arg)
+    override fun tanh(arg: StructureND<Double>): Float64BufferND = super<Floa64FieldOpsND>.tan(arg)

-    override fun asinh(arg: StructureND<Float64>): Float64BufferND = super<Floa64FieldOpsND>.asinh(arg)
+    override fun asinh(arg: StructureND<Double>): Float64BufferND = super<Floa64FieldOpsND>.asinh(arg)

-    override fun acosh(arg: StructureND<Float64>): Float64BufferND = super<Floa64FieldOpsND>.acosh(arg)
+    override fun acosh(arg: StructureND<Double>): Float64BufferND = super<Floa64FieldOpsND>.acosh(arg)

-    override fun atanh(arg: StructureND<Float64>): Float64BufferND = super<Floa64FieldOpsND>.atanh(arg)
+    override fun atanh(arg: StructureND<Double>): Float64BufferND = super<Floa64FieldOpsND>.atanh(arg)

    override fun number(value: Number): Float64BufferND {
        val d = value.toDouble() // minimize conversions
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/StructureND.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/StructureND.kt
@ -14,7 +14,6 @@ import space.kscience.kmath.linear.LinearSpace
 import space.kscience.kmath.operations.Ring
 import space.kscience.kmath.operations.invoke
 import space.kscience.kmath.structures.Buffer
-import space.kscience.kmath.structures.Float64
 import kotlin.math.abs

 public interface StructureAttribute<T> : Attribute<T>
@ -77,8 +76,8 @@ public interface StructureND<out T> : AttributeContainer, WithShape {

        @PerformancePitfall
        public fun contentEquals(
-            st1: StructureND<Float64>,
-            st2: StructureND<Float64>,
+            st1: StructureND<Double>,
+            st2: StructureND<Double>,
            tolerance: Double = 1e-11,
        ): Boolean {
            if (st1 === st2) return true
@ -211,7 +210,7 @@ public fun <T : Comparable<T>> LinearSpace<T, Ring<T>>.contentEquals(
@PerformancePitfall
 public operator fun <T> StructureND<T>.get(vararg index: Int): T = get(index)

-public operator fun StructureND<Float64>.get(vararg index: Int): Double = getDouble(index)
+public operator fun StructureND<Double>.get(vararg index: Int): Double = getDouble(index)

 public operator fun StructureND<Int>.get(vararg index: Int): Int = getInt(index)

--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/VirtualStructureND.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/VirtualStructureND.kt
@ -7,7 +7,6 @@ package space.kscience.kmath.nd

 import space.kscience.kmath.PerformancePitfall
 import space.kscience.kmath.UnstableKMathAPI
-import space.kscience.kmath.structures.Float64

 public open class VirtualStructureND<T>(
    override val shape: ShapeND,
@ -25,7 +24,7 @@ public open class VirtualStructureND<T>(
 public class VirtualDoubleStructureND(
    shape: ShapeND,
    producer: (IntArray) -> Double,
-) : VirtualStructureND<Float64>(shape, producer)
+) : VirtualStructureND<Double>(shape, producer)

@UnstableKMathAPI
 public class VirtualIntStructureND(
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/primitiveStructureND.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/primitiveStructureND.kt
@ -6,9 +6,8 @@
 package space.kscience.kmath.nd

 import space.kscience.kmath.PerformancePitfall
-import space.kscience.kmath.structures.Float64

-public interface StructureNDOfDouble : StructureND<Float64> {
+public interface StructureNDOfDouble : StructureND<Double> {

    /**
     * Guaranteed non-blocking access to content
@ -20,10 +19,10 @@ public interface StructureNDOfDouble : StructureND<Float64> {
 * Optimized method to access primitive without boxing if possible
 */
@OptIn(PerformancePitfall::class)
-public fun StructureND<Float64>.getDouble(index: IntArray): Double =
+public fun StructureND<Double>.getDouble(index: IntArray): Double =
    if (this is StructureNDOfDouble) getDouble(index) else get(index)

-public interface MutableStructureNDOfDouble : StructureNDOfDouble, MutableStructureND<Float64> {
+public interface MutableStructureNDOfDouble : StructureNDOfDouble, MutableStructureND<Double> {

    /**
     * Guaranteed non-blocking access to content
@ -32,7 +31,7 @@ public interface MutableStructureNDOfDouble : StructureNDOfDouble, MutableStruct
 }

@OptIn(PerformancePitfall::class)
-public fun MutableStructureND<Float64>.getDouble(index: IntArray): Double =
+public fun MutableStructureND<Double>.getDouble(index: IntArray): Double =
    if (this is StructureNDOfDouble) getDouble(index) else get(index)


--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/BufferAlgebra.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/BufferAlgebra.kt
@ -6,7 +6,6 @@
 package space.kscience.kmath.operations

 import space.kscience.kmath.structures.Buffer
-import space.kscience.kmath.structures.Float64
 import space.kscience.kmath.structures.MutableBuffer
 import space.kscience.kmath.structures.MutableBufferFactory

@ -183,7 +182,7 @@ public fun <T, A : Field<T>> BufferFieldOps<T, A>.withSize(size: Int): BufferFie

 //Double buffer specialization

-public fun BufferField<Double, *>.buffer(vararg elements: Number): Buffer<Float64> {
+public fun BufferField<Double, *>.buffer(vararg elements: Number): Buffer<Double> {
    require(elements.size == size) { "Expected $size elements but found ${elements.size}" }
    return elementBufferFactory(size) { elements[it].toDouble() }
 }
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/Float64BufferField.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/Float64BufferField.kt
@ -6,7 +6,6 @@
 package space.kscience.kmath.operations

 import space.kscience.kmath.structures.Buffer
-import space.kscience.kmath.structures.Float64
 import space.kscience.kmath.structures.Float64Buffer

 /**
@ -14,23 +13,23 @@ import space.kscience.kmath.structures.Float64Buffer
 *
 * @property size the size of buffers to operate on.
 */
-public class Float64BufferField(public val size: Int) : ExtendedField<Buffer<Float64>>, Float64BufferOps() {
-    override val zero: Buffer<Float64> by lazy { Float64Buffer(size) { 0.0 } }
-    override val one: Buffer<Float64> by lazy { Float64Buffer(size) { 1.0 } }
+public class Float64BufferField(public val size: Int) : ExtendedField<Buffer<Double>>, Float64BufferOps() {
+    override val zero: Buffer<Double> by lazy { Float64Buffer(size) { 0.0 } }
+    override val one: Buffer<Double> by lazy { Float64Buffer(size) { 1.0 } }

-    override fun sinh(arg: Buffer<Float64>): Float64Buffer = super<Float64BufferOps>.sinh(arg)
+    override fun sinh(arg: Buffer<Double>): Float64Buffer = super<Float64BufferOps>.sinh(arg)

-    override fun cosh(arg: Buffer<Float64>): Float64Buffer = super<Float64BufferOps>.cosh(arg)
+    override fun cosh(arg: Buffer<Double>): Float64Buffer = super<Float64BufferOps>.cosh(arg)

-    override fun tanh(arg: Buffer<Float64>): Float64Buffer = super<Float64BufferOps>.tanh(arg)
+    override fun tanh(arg: Buffer<Double>): Float64Buffer = super<Float64BufferOps>.tanh(arg)

-    override fun asinh(arg: Buffer<Float64>): Float64Buffer = super<Float64BufferOps>.asinh(arg)
+    override fun asinh(arg: Buffer<Double>): Float64Buffer = super<Float64BufferOps>.asinh(arg)

-    override fun acosh(arg: Buffer<Float64>): Float64Buffer = super<Float64BufferOps>.acosh(arg)
+    override fun acosh(arg: Buffer<Double>): Float64Buffer = super<Float64BufferOps>.acosh(arg)

-    override fun atanh(arg: Buffer<Float64>): Float64Buffer = super<Float64BufferOps>.atanh(arg)
+    override fun atanh(arg: Buffer<Double>): Float64Buffer = super<Float64BufferOps>.atanh(arg)

-    override fun power(arg: Buffer<Float64>, pow: Number): Float64Buffer = if (pow.isInteger()) {
+    override fun power(arg: Buffer<Double>, pow: Number): Float64Buffer = if (pow.isInteger()) {
        arg.map { it.pow(pow.toInt()) }
    } else {
        arg.map {
@ -39,6 +38,6 @@ public class Float64BufferField(public val size: Int) : ExtendedField<Buffer<Flo
        }
    }

-    override fun unaryOperationFunction(operation: String): (arg: Buffer<Float64>) -> Buffer<Float64> =
+    override fun unaryOperationFunction(operation: String): (arg: Buffer<Double>) -> Buffer<Double> =
        super<ExtendedField>.unaryOperationFunction(operation)
 }
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/Float64BufferOps.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/Float64BufferOps.kt
@ -14,43 +14,43 @@ import kotlin.math.sqrt
 /**
 * [ExtendedFieldOps] over [Float64Buffer].
 */
-public abstract class Float64BufferOps : BufferAlgebra<Double, Float64Field>, ExtendedFieldOps<Buffer<Float64>>,
-    Norm<Buffer<Float64>, Double> {
+public abstract class Float64BufferOps : BufferAlgebra<Double, Float64Field>, ExtendedFieldOps<Buffer<Double>>,
+    Norm<Buffer<Double>, Double> {

    override val elementAlgebra: Float64Field get() = Float64Field

-    override val elementBufferFactory: MutableBufferFactory<Float64> get() = elementAlgebra.bufferFactory
+    override val elementBufferFactory: MutableBufferFactory<Double> get() = elementAlgebra.bufferFactory

    @Suppress("OVERRIDE_BY_INLINE")
    @OptIn(UnstableKMathAPI::class)
-    final override inline fun Buffer<Float64>.map(block: Float64Field.(Double) -> Double): Float64Buffer =
+    final override inline fun Buffer<Double>.map(block: Float64Field.(Double) -> Double): Float64Buffer =
        DoubleArray(size) { Float64Field.block(getDouble(it)) }.asBuffer()


    @OptIn(UnstableKMathAPI::class)
    @Suppress("OVERRIDE_BY_INLINE")
-    final override inline fun Buffer<Float64>.mapIndexed(block: Float64Field.(index: Int, arg: Double) -> Double): Float64Buffer =
+    final override inline fun Buffer<Double>.mapIndexed(block: Float64Field.(index: Int, arg: Double) -> Double): Float64Buffer =
        Float64Buffer(size) { Float64Field.block(it, getDouble(it)) }

    @OptIn(UnstableKMathAPI::class)
    @Suppress("OVERRIDE_BY_INLINE")
-    final override inline fun Buffer<Float64>.zip(
-        other: Buffer<Float64>,
+    final override inline fun Buffer<Double>.zip(
+        other: Buffer<Double>,
        block: Float64Field.(left: Double, right: Double) -> Double,
    ): Float64Buffer {
        require(size == other.size) { "Incompatible buffer sizes. left: ${size}, right: ${other.size}" }
        return Float64Buffer(size) { Float64Field.block(getDouble(it), other.getDouble(it)) }
    }

-    override fun unaryOperationFunction(operation: String): (arg: Buffer<Float64>) -> Buffer<Float64> =
+    override fun unaryOperationFunction(operation: String): (arg: Buffer<Double>) -> Buffer<Double> =
        super<ExtendedFieldOps>.unaryOperationFunction(operation)

-    override fun binaryOperationFunction(operation: String): (left: Buffer<Float64>, right: Buffer<Float64>) -> Buffer<Float64> =
+    override fun binaryOperationFunction(operation: String): (left: Buffer<Double>, right: Buffer<Double>) -> Buffer<Double> =
        super<ExtendedFieldOps>.binaryOperationFunction(operation)

-    override fun Buffer<Float64>.unaryMinus(): Float64Buffer = map { -it }
+    override fun Buffer<Double>.unaryMinus(): Float64Buffer = map { -it }

-    override fun add(left: Buffer<Float64>, right: Buffer<Float64>): Float64Buffer {
+    override fun add(left: Buffer<Double>, right: Buffer<Double>): Float64Buffer {
        require(right.size == left.size) {
            "The size of the first buffer ${left.size} should be the same as for second one: ${right.size} "
        }
@ -62,9 +62,9 @@ public abstract class Float64BufferOps : BufferAlgebra<Double, Float64Field>, Ex
        } else Float64Buffer(DoubleArray(left.size) { left[it] + right[it] })
    }

-    override fun Buffer<Float64>.plus(arg: Buffer<Float64>): Float64Buffer = add(this, arg)
+    override fun Buffer<Double>.plus(arg: Buffer<Double>): Float64Buffer = add(this, arg)

-    override fun Buffer<Float64>.minus(arg: Buffer<Float64>): Float64Buffer {
+    override fun Buffer<Double>.minus(arg: Buffer<Double>): Float64Buffer {
        require(arg.size == this.size) {
            "The size of the first buffer ${this.size} should be the same as for second one: ${arg.size} "
        }
@ -77,7 +77,7 @@ public abstract class Float64BufferOps : BufferAlgebra<Double, Float64Field>, Ex
    }

    //
-//    override fun multiply(a: Buffer<Float64>, k: Number): RealBuffer {
+//    override fun multiply(a: Buffer<Double>, k: Number): RealBuffer {
 //        val kValue = k.toDouble()
 //
 //        return if (a is RealBuffer) {
@ -86,7 +86,7 @@ public abstract class Float64BufferOps : BufferAlgebra<Double, Float64Field>, Ex
 //        } else RealBuffer(DoubleArray(a.size) { a[it] * kValue })
 //    }
 //
-//    override fun divide(a: Buffer<Float64>, k: Number): RealBuffer {
+//    override fun divide(a: Buffer<Double>, k: Number): RealBuffer {
 //        val kValue = k.toDouble()
 //
 //        return if (a is RealBuffer) {
@ -96,7 +96,7 @@ public abstract class Float64BufferOps : BufferAlgebra<Double, Float64Field>, Ex
 //    }

    @UnstableKMathAPI
-    override fun multiply(left: Buffer<Float64>, right: Buffer<Float64>): Float64Buffer {
+    override fun multiply(left: Buffer<Double>, right: Buffer<Double>): Float64Buffer {
        require(right.size == left.size) {
            "The size of the first buffer ${left.size} should be the same as for second one: ${right.size} "
        }
@ -108,7 +108,7 @@ public abstract class Float64BufferOps : BufferAlgebra<Double, Float64Field>, Ex
        } else Float64Buffer(DoubleArray(left.size) { left[it] * right[it] })
    }

-    override fun divide(left: Buffer<Float64>, right: Buffer<Float64>): Float64Buffer {
+    override fun divide(left: Buffer<Double>, right: Buffer<Double>): Float64Buffer {
        require(right.size == left.size) {
            "The size of the first buffer ${left.size} should be the same as for second one: ${right.size} "
        }
@ -120,39 +120,39 @@ public abstract class Float64BufferOps : BufferAlgebra<Double, Float64Field>, Ex
        } else Float64Buffer(DoubleArray(left.size) { left[it] / right[it] })
    }

-    override fun sin(arg: Buffer<Float64>): Float64Buffer = arg.map { sin(it) }
+    override fun sin(arg: Buffer<Double>): Float64Buffer = arg.map { sin(it) }

-    override fun cos(arg: Buffer<Float64>): Float64Buffer = arg.map { cos(it) }
+    override fun cos(arg: Buffer<Double>): Float64Buffer = arg.map { cos(it) }

-    override fun tan(arg: Buffer<Float64>): Float64Buffer = arg.map { tan(it) }
+    override fun tan(arg: Buffer<Double>): Float64Buffer = arg.map { tan(it) }

-    override fun asin(arg: Buffer<Float64>): Float64Buffer = arg.map { asin(it) }
+    override fun asin(arg: Buffer<Double>): Float64Buffer = arg.map { asin(it) }

-    override fun acos(arg: Buffer<Float64>): Float64Buffer = arg.map { acos(it) }
+    override fun acos(arg: Buffer<Double>): Float64Buffer = arg.map { acos(it) }

-    override fun atan(arg: Buffer<Float64>): Float64Buffer = arg.map { atan(it) }
+    override fun atan(arg: Buffer<Double>): Float64Buffer = arg.map { atan(it) }

-    override fun sinh(arg: Buffer<Float64>): Float64Buffer = arg.map { sinh(it) }
+    override fun sinh(arg: Buffer<Double>): Float64Buffer = arg.map { sinh(it) }

-    override fun cosh(arg: Buffer<Float64>): Float64Buffer = arg.map { cosh(it) }
+    override fun cosh(arg: Buffer<Double>): Float64Buffer = arg.map { cosh(it) }

-    override fun tanh(arg: Buffer<Float64>): Float64Buffer = arg.map { tanh(it) }
+    override fun tanh(arg: Buffer<Double>): Float64Buffer = arg.map { tanh(it) }

-    override fun asinh(arg: Buffer<Float64>): Float64Buffer = arg.map { asinh(it) }
+    override fun asinh(arg: Buffer<Double>): Float64Buffer = arg.map { asinh(it) }

-    override fun acosh(arg: Buffer<Float64>): Float64Buffer = arg.map { acosh(it) }
+    override fun acosh(arg: Buffer<Double>): Float64Buffer = arg.map { acosh(it) }

-    override fun atanh(arg: Buffer<Float64>): Float64Buffer = arg.map { atanh(it) }
+    override fun atanh(arg: Buffer<Double>): Float64Buffer = arg.map { atanh(it) }

-    override fun exp(arg: Buffer<Float64>): Float64Buffer = arg.map { exp(it) }
+    override fun exp(arg: Buffer<Double>): Float64Buffer = arg.map { exp(it) }

-    override fun ln(arg: Buffer<Float64>): Float64Buffer = arg.map { ln(it) }
+    override fun ln(arg: Buffer<Double>): Float64Buffer = arg.map { ln(it) }

-    override fun norm(arg: Buffer<Float64>): Double = Float64L2Norm.norm(arg)
+    override fun norm(arg: Buffer<Double>): Double = Float64L2Norm.norm(arg)

-    override fun scale(a: Buffer<Float64>, value: Double): Float64Buffer = a.map { it * value }
+    override fun scale(a: Buffer<Double>, value: Double): Float64Buffer = a.map { it * value }

-    override fun power(arg: Buffer<Float64>, pow: Number): Buffer<Float64> = if (pow is Int) {
+    override fun power(arg: Buffer<Double>, pow: Number): Buffer<Double> = if (pow is Int) {
        arg.map { it.pow(pow) }
    } else {
        arg.map { it.pow(pow.toDouble()) }
@ -161,11 +161,11 @@ public abstract class Float64BufferOps : BufferAlgebra<Double, Float64Field>, Ex
    public companion object : Float64BufferOps()
 }

-public object Float64L2Norm : Norm<Point<Float64>, Double> {
-    override fun norm(arg: Point<Float64>): Double = sqrt(arg.fold(0.0) { acc: Double, d: Double -> acc + d.pow(2) })
+public object Float64L2Norm : Norm<Point<Double>, Double> {
+    override fun norm(arg: Point<Double>): Double = sqrt(arg.fold(0.0) { acc: Double, d: Double -> acc + d.pow(2) })
 }

-public fun Float64BufferOps.sum(buffer: Buffer<Float64>): Double = buffer.reduce(Double::plus)
+public fun Float64BufferOps.sum(buffer: Buffer<Double>): Double = buffer.reduce(Double::plus)

 /**
 * Sum of elements using given [conversion]
@ -173,7 +173,7 @@ public fun Float64BufferOps.sum(buffer: Buffer<Float64>): Double = buffer.reduce
 public inline fun <T> Float64BufferOps.sumOf(buffer: Buffer<T>, conversion: (T) -> Double): Double =
    buffer.fold(0.0) { acc, value -> acc + conversion(value) }

-public fun Float64BufferOps.average(buffer: Buffer<Float64>): Double = sum(buffer) / buffer.size
+public fun Float64BufferOps.average(buffer: Buffer<Double>): Double = sum(buffer) / buffer.size

 /**
 * Average of elements using given [conversion]
@ -181,14 +181,14 @@ public fun Float64BufferOps.average(buffer: Buffer<Float64>): Double = sum(buffe
 public inline fun <T> Float64BufferOps.averageOf(buffer: Buffer<T>, conversion: (T) -> Double): Double =
    sumOf(buffer, conversion) / buffer.size

-public fun Float64BufferOps.dispersion(buffer: Buffer<Float64>): Double {
+public fun Float64BufferOps.dispersion(buffer: Buffer<Double>): Double {
    val av = average(buffer)
    return buffer.fold(0.0) { acc, value -> acc + (value - av).pow(2) } / buffer.size
 }

-public fun Float64BufferOps.std(buffer: Buffer<Float64>): Double = sqrt(dispersion(buffer))
+public fun Float64BufferOps.std(buffer: Buffer<Double>): Double = sqrt(dispersion(buffer))

-public fun Float64BufferOps.covariance(x: Buffer<Float64>, y: Buffer<Float64>): Double {
+public fun Float64BufferOps.covariance(x: Buffer<Double>, y: Buffer<Double>): Double {
    require(x.size == y.size) { "Expected buffers of the same size, but x.size == ${x.size} and y.size == ${y.size}" }
    val xMean = average(x)
    val yMean = average(y)
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/numbers.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/numbers.kt
@ -4,7 +4,6 @@
 */
 package space.kscience.kmath.operations

-import space.kscience.kmath.structures.Float64
 import space.kscience.kmath.structures.MutableBufferFactory
 import kotlin.math.pow as kpow

@ -67,8 +66,8 @@ public interface ExtendedField<T> : ExtendedFieldOps<T>, Field<T>, NumericAlgebr
 * A field for [Double] without boxing. Does not produce an appropriate field element.
 */
@Suppress("EXTENSION_SHADOWED_BY_MEMBER")
-public object Float64Field : ExtendedField<Float64>, Norm<Double, Double>, ScaleOperations<Float64> {
-    override val bufferFactory: MutableBufferFactory<Float64> = MutableBufferFactory()
+public object Float64Field : ExtendedField<Double>, Norm<Double, Double>, ScaleOperations<Double> {
+    override val bufferFactory: MutableBufferFactory<Double> = MutableBufferFactory()

    override val zero: Double get() = 0.0
    override val one: Double get() = 1.0
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/Buffer.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/Buffer.kt
@ -115,7 +115,7 @@ public fun <T> Buffer(
    size: Int,
    initializer: (Int) -> T,
 ): Buffer<T> = when (type.kType) {
-    typeOf<Float64>() -> MutableBuffer.double(size) { initializer(it) as Double } as Buffer<T>
+    typeOf<Double>() -> MutableBuffer.double(size) { initializer(it) as Double } as Buffer<T>
    typeOf<Short>() -> MutableBuffer.short(size) { initializer(it) as Short } as Buffer<T>
    typeOf<Int>() -> MutableBuffer.int(size) { initializer(it) as Int } as Buffer<T>
    typeOf<Long>() -> MutableBuffer.long(size) { initializer(it) as Long } as Buffer<T>
@ -134,7 +134,7 @@ public inline fun <reified T> Buffer(size: Int, initializer: (Int) -> T): Buffer
    //code duplication here because we want to inline initializers
    val type = safeTypeOf<T>()
    return when (type.kType) {
-        typeOf<Float64>() -> MutableBuffer.double(size) { initializer(it) as Double } as Buffer<T>
+        typeOf<Double>() -> MutableBuffer.double(size) { initializer(it) as Double } as Buffer<T>
        typeOf<Short>() -> MutableBuffer.short(size) { initializer(it) as Short } as Buffer<T>
        typeOf<Int>() -> MutableBuffer.int(size) { initializer(it) as Int } as Buffer<T>
        typeOf<Long>() -> MutableBuffer.long(size) { initializer(it) as Long } as Buffer<T>
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/Float64Buffer.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/Float64Buffer.kt
@ -14,7 +14,7 @@ import kotlin.jvm.JvmInline
 * @property array the underlying array.
 */
@JvmInline
-public value class Float64Buffer(public val array: DoubleArray) : PrimitiveBuffer<Float64> {
+public value class Float64Buffer(public val array: DoubleArray) : PrimitiveBuffer<Double> {

    override val size: Int get() = array.size

@ -54,7 +54,7 @@ public fun Float64Buffer(vararg doubles: Double): Float64Buffer = Float64Buffer(
 /**
 * Returns a new [DoubleArray] containing all the elements of this [Buffer].
 */
-public fun Buffer<Float64>.toDoubleArray(): DoubleArray = when (this) {
+public fun Buffer<Double>.toDoubleArray(): DoubleArray = when (this) {
    is Float64Buffer -> array
    else -> DoubleArray(size, ::get)
 }
@ -62,7 +62,7 @@ public fun Buffer<Float64>.toDoubleArray(): DoubleArray = when (this) {
 /**
 * Represent this buffer as [Float64Buffer]. Does not guarantee that changes in the original buffer are reflected on this buffer.
 */
-public fun Buffer<Float64>.toFloat64Buffer(): Float64Buffer = when (this) {
+public fun Buffer<Double>.toFloat64Buffer(): Float64Buffer = when (this) {
    is Float64Buffer -> this
    else -> DoubleArray(size, ::get).asBuffer()
 }
@ -79,5 +79,5 @@ public fun DoubleArray.asBuffer(): Float64Buffer = Float64Buffer(this)
 public fun interface Float64BufferTransform : BufferTransform<Double, Double> {
    public fun transform(arg: Float64Buffer): Float64Buffer

-    override fun transform(arg: Buffer<Float64>): Float64Buffer = arg.toFloat64Buffer()
+    override fun transform(arg: Buffer<Double>): Float64Buffer = arg.toFloat64Buffer()
 }
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/MutableBuffer.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/MutableBuffer.kt
@ -99,7 +99,7 @@ public inline fun <T> MutableBuffer(
    typeOf<Int32>() -> MutableBuffer.int(size) { initializer(it) as Int32 } as MutableBuffer<T>
    typeOf<Int64>() -> MutableBuffer.long(size) { initializer(it) as Int64 } as MutableBuffer<T>
    typeOf<Float>() -> MutableBuffer.float(size) { initializer(it) as Float } as MutableBuffer<T>
-    typeOf<Float64>() -> MutableBuffer.double(size) { initializer(it) as Double } as MutableBuffer<T>
+    typeOf<Double>() -> MutableBuffer.double(size) { initializer(it) as Double } as MutableBuffer<T>
    //TODO add unsigned types
    else -> MutableListBuffer(MutableList(size, initializer))
 }
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/bufferPrimitiveAccess.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/structures/bufferPrimitiveAccess.kt
@ -11,7 +11,7 @@ import space.kscience.kmath.UnstableKMathAPI
 * Non-boxing access to primitive [Double]
 */
@UnstableKMathAPI
-public fun Buffer<Float64>.getDouble(index: Int): Double = if (this is BufferView) {
+public fun Buffer<Double>.getDouble(index: Int): Double = if (this is BufferView) {
    val originIndex = originIndex(index)
    if (originIndex >= 0) {
        origin.getDouble(originIndex)
--- a/kmath-core/src/commonTest/kotlin/space/kscience/kmath/expressions/ExpressionFieldTest.kt
+++ b/kmath-core/src/commonTest/kotlin/space/kscience/kmath/expressions/ExpressionFieldTest.kt
@ -6,7 +6,6 @@
 package space.kscience.kmath.expressions

 import space.kscience.kmath.operations.Float64Field
-import space.kscience.kmath.structures.Float64
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFails
@ -38,7 +37,7 @@ class ExpressionFieldTest {

    @Test
    fun valueExpression() {
-        val expressionBuilder: FunctionalExpressionField<Double, *>.() -> Expression<Float64> = {
+        val expressionBuilder: FunctionalExpressionField<Double, *>.() -> Expression<Double> = {
            val x by binding
            x * x + 2 * x + one
        }
--- a/kmath-core/src/commonTest/kotlin/space/kscience/kmath/expressions/SimpleAutoDiffTest.kt
+++ b/kmath-core/src/commonTest/kotlin/space/kscience/kmath/expressions/SimpleAutoDiffTest.kt
@ -8,7 +8,6 @@ package space.kscience.kmath.expressions
 import space.kscience.kmath.operations.Float64Field
 import space.kscience.kmath.operations.bindSymbol
 import space.kscience.kmath.structures.Buffer
-import space.kscience.kmath.structures.Float64
 import space.kscience.kmath.structures.asBuffer
 import kotlin.math.E
 import kotlin.math.PI
@ -22,18 +21,18 @@ internal class SimpleAutoDiffTest {

    fun dx(
        xBinding: Pair<Symbol, Double>,
-        body: SimpleAutoDiffField<Double, Float64Field>.(x: AutoDiffValue<Float64>) -> AutoDiffValue<Float64>,
-    ): DerivationResult<Float64> = Float64Field.simpleAutoDiff(xBinding) { body(bindSymbol(xBinding.first)) }
+        body: SimpleAutoDiffField<Double, Float64Field>.(x: AutoDiffValue<Double>) -> AutoDiffValue<Double>,
+    ): DerivationResult<Double> = Float64Field.simpleAutoDiff(xBinding) { body(bindSymbol(xBinding.first)) }

    fun dxy(
        xBinding: Pair<Symbol, Double>,
        yBinding: Pair<Symbol, Double>,
-        body: SimpleAutoDiffField<Double, Float64Field>.(x: AutoDiffValue<Float64>, y: AutoDiffValue<Float64>) -> AutoDiffValue<Float64>,
-    ): DerivationResult<Float64> = Float64Field.simpleAutoDiff(xBinding, yBinding) {
+        body: SimpleAutoDiffField<Double, Float64Field>.(x: AutoDiffValue<Double>, y: AutoDiffValue<Double>) -> AutoDiffValue<Double>,
+    ): DerivationResult<Double> = Float64Field.simpleAutoDiff(xBinding, yBinding) {
        body(bindSymbol(xBinding.first), bindSymbol(yBinding.first))
    }

-    fun diff(block: SimpleAutoDiffField<Double, Float64Field>.() -> AutoDiffValue<Float64>): SimpleAutoDiffExpression<Double, Float64Field> {
+    fun diff(block: SimpleAutoDiffField<Double, Float64Field>.() -> AutoDiffValue<Double>): SimpleAutoDiffExpression<Double, Float64Field> {
        return SimpleAutoDiffExpression(Float64Field, block)
    }

--- a/kmath-core/src/commonTest/kotlin/space/kscience/kmath/linear/MatrixTest.kt
+++ b/kmath-core/src/commonTest/kotlin/space/kscience/kmath/linear/MatrixTest.kt
@ -10,7 +10,6 @@ import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.nd.StructureND
 import space.kscience.kmath.operations.Float64Field
 import space.kscience.kmath.operations.algebra
-import space.kscience.kmath.structures.Float64
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertTrue
@ -39,7 +38,7 @@ class MatrixTest {

    @Test
    fun testMatrixExtension() = Double.algebra.linearSpace.run {
-        val transitionMatrix: Matrix<Float64> = VirtualMatrix(6, 6) { row, col ->
+        val transitionMatrix: Matrix<Double> = VirtualMatrix(6, 6) { row, col ->
            when {
                col == 0 -> .50
                row + 1 == col -> .50
@ -48,7 +47,7 @@ class MatrixTest {
            }
        }

-        infix fun Matrix<Float64>.pow(power: Int): Matrix<Float64> {
+        infix fun Matrix<Double>.pow(power: Int): Matrix<Double> {
            var res = this
            repeat(power - 1) {
                res = res dot this@pow
--- a/kmath-core/src/jvmMain/kotlin/space/kscience/kmath/linear/Float64ParallelLinearSpace.kt
+++ b/kmath-core/src/jvmMain/kotlin/space/kscience/kmath/linear/Float64ParallelLinearSpace.kt
@ -11,7 +11,6 @@ import space.kscience.kmath.operations.Float64BufferOps
 import space.kscience.kmath.operations.Float64Field
 import space.kscience.kmath.operations.invoke
 import space.kscience.kmath.structures.Buffer
-import space.kscience.kmath.structures.Float64
 import space.kscience.kmath.structures.Float64Buffer
 import space.kscience.kmath.structures.asBuffer
 import java.util.stream.IntStream
@ -26,7 +25,7 @@ public object Float64ParallelLinearSpace : LinearSpace<Double, Float64Field> {
        rows: Int,
        columns: Int,
        initializer: Float64Field.(i: Int, j: Int) -> Double,
-    ): Matrix<Float64> {
+    ): Matrix<Double> {
        val shape = ShapeND(rows, columns)
        val indexer = BufferAlgebraND.defaultIndexerBuilder(shape)

@ -44,29 +43,29 @@ public object Float64ParallelLinearSpace : LinearSpace<Double, Float64Field> {
    override fun buildVector(size: Int, initializer: Float64Field.(Int) -> Double): Float64Buffer =
        IntStream.range(0, size).parallel().mapToDouble { Float64Field.initializer(it) }.toArray().asBuffer()

-    override fun Matrix<Float64>.unaryMinus(): Matrix<Float64> = Floa64FieldOpsND {
+    override fun Matrix<Double>.unaryMinus(): Matrix<Double> = Floa64FieldOpsND {
        asND().map { -it }.as2D()
    }

-    override fun Matrix<Float64>.plus(other: Matrix<Float64>): Matrix<Float64> = Floa64FieldOpsND {
+    override fun Matrix<Double>.plus(other: Matrix<Double>): Matrix<Double> = Floa64FieldOpsND {
        require(shape == other.shape) { "Shape mismatch on Matrix::plus. Expected $shape but found ${other.shape}" }
        asND().plus(other.asND()).as2D()
    }

-    override fun Matrix<Float64>.minus(other: Matrix<Float64>): Matrix<Float64> = Floa64FieldOpsND {
+    override fun Matrix<Double>.minus(other: Matrix<Double>): Matrix<Double> = Floa64FieldOpsND {
        require(shape == other.shape) { "Shape mismatch on Matrix::minus. Expected $shape but found ${other.shape}" }
        asND().minus(other.asND()).as2D()
    }

    // Create a continuous in-memory representation of this vector for better memory layout handling
-    private fun Buffer<Float64>.linearize() = if (this is Float64Buffer) {
+    private fun Buffer<Double>.linearize() = if (this is Float64Buffer) {
        this.array
    } else {
        DoubleArray(size) { get(it) }
    }

    @OptIn(PerformancePitfall::class)
-    override fun Matrix<Float64>.dot(other: Matrix<Float64>): Matrix<Float64> {
+    override fun Matrix<Double>.dot(other: Matrix<Double>): Matrix<Double> {
        require(colNum == other.rowNum) { "Matrix dot operation dimension mismatch: ($rowNum, $colNum) x (${other.rowNum}, ${other.colNum})" }
        val rows = this@dot.rows.map { it.linearize() }
        val columns = other.columns.map { it.linearize() }
@ -83,7 +82,7 @@ public object Float64ParallelLinearSpace : LinearSpace<Double, Float64Field> {
    }

    @OptIn(PerformancePitfall::class)
-    override fun Matrix<Float64>.dot(vector: Point<Float64>): Float64Buffer {
+    override fun Matrix<Double>.dot(vector: Point<Double>): Float64Buffer {
        require(colNum == vector.size) { "Matrix dot vector operation dimension mismatch: ($rowNum, $colNum) x (${vector.size})" }
        val rows = this@dot.rows.map { it.linearize() }
        val indices = 0 until this.colNum
@ -98,27 +97,27 @@ public object Float64ParallelLinearSpace : LinearSpace<Double, Float64Field> {

    }

-    override fun Matrix<Float64>.times(value: Double): Matrix<Float64> = Floa64FieldOpsND {
+    override fun Matrix<Double>.times(value: Double): Matrix<Double> = Floa64FieldOpsND {
        asND().map { it * value }.as2D()
    }

-    public override fun Point<Float64>.plus(other: Point<Float64>): Float64Buffer = Float64BufferOps.run {
+    public override fun Point<Double>.plus(other: Point<Double>): Float64Buffer = Float64BufferOps.run {
        this@plus + other
    }

-    public override fun Point<Float64>.minus(other: Point<Float64>): Float64Buffer = Float64BufferOps.run {
+    public override fun Point<Double>.minus(other: Point<Double>): Float64Buffer = Float64BufferOps.run {
        this@minus - other
    }

-    public override fun Point<Float64>.times(value: Double): Float64Buffer = Float64BufferOps.run {
+    public override fun Point<Double>.times(value: Double): Float64Buffer = Float64BufferOps.run {
        scale(this@times, value)
    }

-    public operator fun Point<Float64>.div(value: Double): Float64Buffer = Float64BufferOps.run {
+    public operator fun Point<Double>.div(value: Double): Float64Buffer = Float64BufferOps.run {
        scale(this@div, 1.0 / value)
    }

-    public override fun Double.times(v: Point<Float64>): Float64Buffer = v * this
+    public override fun Double.times(v: Point<Double>): Float64Buffer = v * this


 }
--- a/kmath-core/src/jvmMain/kotlin/space/kscience/kmath/structures/parallelMutableBuffer.kt
+++ b/kmath-core/src/jvmMain/kotlin/space/kscience/kmath/structures/parallelMutableBuffer.kt
@ -30,7 +30,7 @@ public fun <T> MutableBuffer.Companion.parallel(
        .asBuffer() as MutableBuffer<T>

    typeOf<Float>() -> Float32Buffer(size) { initializer(it) as Float } as MutableBuffer<T>
-    typeOf<Float64>() -> IntStream.range(0, size).parallel().mapToDouble { initializer(it) as Float64 }.toArray()
+    typeOf<Double>() -> IntStream.range(0, size).parallel().mapToDouble { initializer(it) as Float64 }.toArray()
        .asBuffer() as MutableBuffer<T>
    //TODO add unsigned types
    else -> IntStream.range(0, size).parallel().mapToObj { initializer(it) }.collect(Collectors.toList<T>())
--- a/kmath-core/src/jvmTest/kotlin/space/kscience/kmath/linear/ParallelMatrixTest.kt
+++ b/kmath-core/src/jvmTest/kotlin/space/kscience/kmath/linear/ParallelMatrixTest.kt
@ -9,7 +9,6 @@ import space.kscience.kmath.PerformancePitfall
 import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.nd.StructureND
 import space.kscience.kmath.operations.Float64Field
-import space.kscience.kmath.structures.Float64
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertTrue
@ -38,7 +37,7 @@ class ParallelMatrixTest {

    @Test
    fun testMatrixExtension() = Float64Field.linearSpace.parallel {
-        val transitionMatrix: Matrix<Float64> = VirtualMatrix(6, 6) { row, col ->
+        val transitionMatrix: Matrix<Double> = VirtualMatrix(6, 6) { row, col ->
            when {
                col == 0 -> .50
                row + 1 == col -> .50
@ -47,7 +46,7 @@ class ParallelMatrixTest {
            }
        }

-        infix fun Matrix<Float64>.pow(power: Int): Matrix<Float64> {
+        infix fun Matrix<Double>.pow(power: Int): Matrix<Double> {
            var res = this
            repeat(power - 1) {
                res = res dot this@pow
--- a/kmath-coroutines/src/commonMain/kotlin/space/kscience/kmath/chains/BlockingDoubleChain.kt
+++ b/kmath-coroutines/src/commonMain/kotlin/space/kscience/kmath/chains/BlockingDoubleChain.kt
@ -5,13 +5,12 @@

 package space.kscience.kmath.chains

-import space.kscience.kmath.structures.Float64
 import space.kscience.kmath.structures.Float64Buffer

 /**
 * Chunked, specialized chain for double values, which supports blocking [nextBlocking] operation
 */
-public interface BlockingDoubleChain : BlockingBufferChain<Float64> {
+public interface BlockingDoubleChain : BlockingBufferChain<Double> {

    /**
     * Returns an [DoubleArray] chunk of [size] values of [next].
--- a/kmath-coroutines/src/commonMain/kotlin/space/kscience/kmath/streaming/BufferFlow.kt
+++ b/kmath-coroutines/src/commonMain/kotlin/space/kscience/kmath/streaming/BufferFlow.kt
@ -17,7 +17,6 @@ import space.kscience.kmath.chains.BlockingDoubleChain
 import space.kscience.kmath.operations.Group
 import space.kscience.kmath.structures.Buffer
 import space.kscience.kmath.structures.BufferFactory
-import space.kscience.kmath.structures.Float64
 import space.kscience.kmath.structures.Float64Buffer

 /**
@ -57,7 +56,7 @@ public fun <T> Flow<T>.chunked(bufferSize: Int, bufferFactory: BufferFactory<T>)
 /**
 * Specialized flow chunker for real buffer
 */
-public fun Flow<Float64>.chunked(bufferSize: Int): Flow<Float64Buffer> = flow {
+public fun Flow<Double>.chunked(bufferSize: Int): Flow<Float64Buffer> = flow {
    require(bufferSize > 0) { "Resulting chunk size must be more than zero" }

    if (this@chunked is BlockingDoubleChain) {
--- a/kmath-ejml/build.gradle.kts
+++ b/kmath-ejml/build.gradle.kts
@ -1,20 +1,12 @@
 plugins {
-    id("space.kscience.gradle.mpp")
+    id("space.kscience.gradle.jvm")
 }

 val ejmlVerision = "0.43.1"

-kscience {
-    jvm()
-    jvmMain {
-        api(projects.kmathCore)
-        api(projects.kmathComplex)
-        api("org.ejml:ejml-all:$ejmlVerision")
-    }
-
-    jvmTest {
-        implementation(projects.testUtils)
-    }
+dependencies {
+    api("org.ejml:ejml-all:$ejmlVerision")
+    api(projects.kmathCore)
 }

 readme {
@ -36,3 +28,11 @@ readme {
        ref = "src/main/kotlin/space/kscience/kmath/ejml/EjmlLinearSpace.kt"
    ) { "LinearSpace implementations." }
 }
+
+//kotlin.sourceSets.main {
+//    val codegen by tasks.creating {
+//        ejmlCodegen(kotlin.srcDirs.first().absolutePath + "/space/kscience/kmath/ejml/_generated.kt")
+//    }
+//
+//    kotlin.srcDirs(files().builtBy(codegen))
+//}
--- a/kmath-ejml/src/jvmMain/kotlin/space/kscience/kmath/ejml/EjmlLinearSpace.kt
+++ b/kmath-ejml/src/jvmMain/kotlin/space/kscience/kmath/ejml/EjmlLinearSpace.kt
@ -6,13 +6,9 @@
 package space.kscience.kmath.ejml

 import space.kscience.kmath.UnstableKMathAPI
-import space.kscience.kmath.linear.Inverted
-import space.kscience.kmath.linear.LinearSpace
-import space.kscience.kmath.linear.Matrix
-import space.kscience.kmath.linear.Point
-import space.kscience.kmath.nd.Structure2D
+import space.kscience.kmath.linear.*
+import space.kscience.kmath.operations.Float64Field
 import space.kscience.kmath.operations.Ring
-import space.kscience.kmath.structures.Float64

 /**
 * [LinearSpace] implementation specialized for a certain EJML type.
@ -42,6 +38,6 @@ public abstract class EjmlLinearSpace<T : Any, out A : Ring<T>, out M : org.ejml
    public abstract override fun buildVector(size: Int, initializer: A.(Int) -> T): EjmlVector<T, M>

    @UnstableKMathAPI
-    public fun Structure2D<T>.inverted(): Matrix<Float64> =
-        computeAttribute(this, Inverted()) ?: error("Can't invert matrix")
+    public fun EjmlMatrix<T, *>.inverted(): Matrix<Double> =
+        computeAttribute(this, Float64Field.linearSpace.Inverted)!!
 }
--- a/kmath-ejml/src/jvmMain/kotlin/space/kscience/kmath/ejml/EjmlMatrix.kt
+++ b/kmath-ejml/src/jvmMain/kotlin/space/kscience/kmath/ejml/EjmlMatrix.kt
--- a/kmath-ejml/src/jvmMain/kotlin/space/kscience/kmath/ejml/EjmlVector.kt
+++ b/kmath-ejml/src/jvmMain/kotlin/space/kscience/kmath/ejml/EjmlVector.kt
--- a/kmath-ejml/src/jvmMain/kotlin/space/kscience/kmath/ejml/implementations.kt
+++ b/kmath-ejml/src/jvmMain/kotlin/space/kscience/kmath/ejml/implementations.kt
@ -12,8 +12,6 @@ import org.ejml.dense.row.CommonOps_DDRM
 import org.ejml.dense.row.CommonOps_FDRM
 import org.ejml.dense.row.factory.DecompositionFactory_DDRM
 import org.ejml.dense.row.factory.DecompositionFactory_FDRM
-import org.ejml.interfaces.decomposition.EigenDecomposition_F32
-import org.ejml.interfaces.decomposition.EigenDecomposition_F64
 import org.ejml.sparse.FillReducing
 import org.ejml.sparse.csc.CommonOps_DSCC
 import org.ejml.sparse.csc.CommonOps_FSCC
@ -21,8 +19,6 @@ import org.ejml.sparse.csc.factory.DecompositionFactory_DSCC
 import org.ejml.sparse.csc.factory.DecompositionFactory_FSCC
 import space.kscience.attributes.SafeType
 import space.kscience.attributes.safeTypeOf
-import space.kscience.kmath.UnstableKMathAPI
-import space.kscience.kmath.complex.Complex
 import space.kscience.kmath.linear.*
 import space.kscience.kmath.linear.Matrix
 import space.kscience.kmath.nd.Structure2D
@ -31,15 +27,9 @@ import space.kscience.kmath.operations.Float32Field
 import space.kscience.kmath.operations.Float64Field
 import space.kscience.kmath.operations.invoke
 import space.kscience.kmath.structures.Float32
-import space.kscience.kmath.structures.Float64
 import space.kscience.kmath.structures.IntBuffer
 import space.kscience.kmath.structures.asBuffer

-/**
- * Copy EJML [Complex_F64] into KMath [Complex]
- */
-public fun Complex_F64.toKMathComplex(): Complex = Complex(real, imaginary)
-
 /**
 * [EjmlVector] specialization for [Double].
 */
@ -89,16 +79,16 @@ public object EjmlLinearSpaceDDRM : EjmlLinearSpace<Double, Float64Field, DMatri
     */
    override val elementAlgebra: Float64Field get() = Float64Field

-    override val type: SafeType<Float64> get() = safeTypeOf()
+    override val type: SafeType<Double> get() = safeTypeOf()

    @Suppress("UNCHECKED_CAST")
-    override fun Matrix<Float64>.toEjml(): EjmlDoubleMatrix<DMatrixRMaj> = when {
+    override fun Matrix<Double>.toEjml(): EjmlDoubleMatrix<DMatrixRMaj> = when {
        this is EjmlDoubleMatrix<*> && origin is DMatrixRMaj -> this as EjmlDoubleMatrix<DMatrixRMaj>
        else -> buildMatrix(rowNum, colNum) { i, j -> get(i, j) }
    }

    @Suppress("UNCHECKED_CAST")
-    override fun Point<Float64>.toEjml(): EjmlDoubleVector<DMatrixRMaj> = when {
+    override fun Point<Double>.toEjml(): EjmlDoubleVector<DMatrixRMaj> = when {
        this is EjmlDoubleVector<*> && origin is DMatrixRMaj -> this as EjmlDoubleVector<DMatrixRMaj>
        else -> EjmlDoubleVector(DMatrixRMaj(size, 1).also {
            (0 until it.numRows).forEach { row -> it[row, 0] = get(row) }
@ -125,21 +115,21 @@ public object EjmlLinearSpaceDDRM : EjmlLinearSpace<Double, Float64Field, DMatri
    private fun <T : DMatrix> T.wrapMatrix() = EjmlDoubleMatrix(this)
    private fun <T : DMatrix> T.wrapVector() = EjmlDoubleVector(this)

-    override fun Matrix<Float64>.unaryMinus(): Matrix<Float64> = this * elementAlgebra { -one }
+    override fun Matrix<Double>.unaryMinus(): Matrix<Double> = this * elementAlgebra { -one }

-    override fun Matrix<Float64>.dot(other: Matrix<Float64>): EjmlDoubleMatrix<DMatrixRMaj> {
+    override fun Matrix<Double>.dot(other: Matrix<Double>): EjmlDoubleMatrix<DMatrixRMaj> {
        val out = DMatrixRMaj(1, 1)
        CommonOps_DDRM.mult(toEjml().origin, other.toEjml().origin, out)
        return out.wrapMatrix()
    }

-    override fun Matrix<Float64>.dot(vector: Point<Float64>): EjmlDoubleVector<DMatrixRMaj> {
+    override fun Matrix<Double>.dot(vector: Point<Double>): EjmlDoubleVector<DMatrixRMaj> {
        val out = DMatrixRMaj(1, 1)
        CommonOps_DDRM.mult(toEjml().origin, vector.toEjml().origin, out)
        return out.wrapVector()
    }

-    override operator fun Matrix<Float64>.minus(other: Matrix<Float64>): EjmlDoubleMatrix<DMatrixRMaj> {
+    override operator fun Matrix<Double>.minus(other: Matrix<Double>): EjmlDoubleMatrix<DMatrixRMaj> {
        val out = DMatrixRMaj(1, 1)

        CommonOps_DDRM.add(
@ -153,19 +143,19 @@ public object EjmlLinearSpaceDDRM : EjmlLinearSpace<Double, Float64Field, DMatri
        return out.wrapMatrix()
    }

-    override operator fun Matrix<Float64>.times(value: Double): EjmlDoubleMatrix<DMatrixRMaj> {
+    override operator fun Matrix<Double>.times(value: Double): EjmlDoubleMatrix<DMatrixRMaj> {
        val res = DMatrixRMaj(1, 1)
        CommonOps_DDRM.scale(value, toEjml().origin, res)
        return res.wrapMatrix()
    }

-    override fun Point<Float64>.unaryMinus(): EjmlDoubleVector<DMatrixRMaj> {
+    override fun Point<Double>.unaryMinus(): EjmlDoubleVector<DMatrixRMaj> {
        val res = DMatrixRMaj(1, 1)
        CommonOps_DDRM.changeSign(toEjml().origin, res)
        return res.wrapVector()
    }

-    override fun Matrix<Float64>.plus(other: Matrix<Float64>): EjmlDoubleMatrix<DMatrixRMaj> {
+    override fun Matrix<Double>.plus(other: Matrix<Double>): EjmlDoubleMatrix<DMatrixRMaj> {
        val out = DMatrixRMaj(1, 1)

        CommonOps_DDRM.add(
@ -179,7 +169,7 @@ public object EjmlLinearSpaceDDRM : EjmlLinearSpace<Double, Float64Field, DMatri
        return out.wrapMatrix()
    }

-    override fun Point<Float64>.plus(other: Point<Float64>): EjmlDoubleVector<DMatrixRMaj> {
+    override fun Point<Double>.plus(other: Point<Double>): EjmlDoubleVector<DMatrixRMaj> {
        val out = DMatrixRMaj(1, 1)

        CommonOps_DDRM.add(
@ -193,7 +183,7 @@ public object EjmlLinearSpaceDDRM : EjmlLinearSpace<Double, Float64Field, DMatri
        return out.wrapVector()
    }

-    override fun Point<Float64>.minus(other: Point<Float64>): EjmlDoubleVector<DMatrixRMaj> {
+    override fun Point<Double>.minus(other: Point<Double>): EjmlDoubleVector<DMatrixRMaj> {
        val out = DMatrixRMaj(1, 1)

        CommonOps_DDRM.add(
@ -207,19 +197,18 @@ public object EjmlLinearSpaceDDRM : EjmlLinearSpace<Double, Float64Field, DMatri
        return out.wrapVector()
    }

-    override fun Double.times(m: Matrix<Float64>): EjmlDoubleMatrix<DMatrixRMaj> = m * this
+    override fun Double.times(m: Matrix<Double>): EjmlDoubleMatrix<DMatrixRMaj> = m * this

-    override fun Point<Float64>.times(value: Double): EjmlDoubleVector<DMatrixRMaj> {
+    override fun Point<Double>.times(value: Double): EjmlDoubleVector<DMatrixRMaj> {
        val res = DMatrixRMaj(1, 1)
        CommonOps_DDRM.scale(value, toEjml().origin, res)
        return res.wrapVector()
    }

-    override fun Double.times(v: Point<Float64>): EjmlDoubleVector<DMatrixRMaj> = v * this
+    override fun Double.times(v: Point<Double>): EjmlDoubleVector<DMatrixRMaj> = v * this

-    @OptIn(UnstableKMathAPI::class)
-    override fun <V, A : StructureAttribute<V>> computeAttribute(structure: Structure2D<Float64>, attribute: A): V? {
-        val origin: DMatrixRMaj = structure.toEjml().origin
+    override fun <V, A : StructureAttribute<V>> computeAttribute(structure: Structure2D<Double>, attribute: A): V? {
+        val origin = structure.toEjml().origin

        val raw: Any? = when (attribute) {
            Inverted -> {
@ -229,28 +218,28 @@ public object EjmlLinearSpaceDDRM : EjmlLinearSpace<Double, Float64Field, DMatri
            }

            Determinant -> CommonOps_DDRM.det(origin)
-            SVD -> object : SingularValueDecomposition<Float64> {
+            SVD -> object : SingularValueDecomposition<Double> {
                val ejmlSvd by lazy {
                    DecompositionFactory_DDRM
                        .svd(origin.numRows, origin.numCols, true, true, false)
                        .apply { decompose(origin.copy()) }
                }
-                override val u: Matrix<Float64> get() = ejmlSvd.getU(null, false).wrapMatrix()
+                override val u: Matrix<Double> get() = ejmlSvd.getU(null, false).wrapMatrix()

-                override val s: Matrix<Float64> get() = ejmlSvd.getW(null).wrapMatrix()
-                override val v: Matrix<Float64> get() = ejmlSvd.getV(null, false).wrapMatrix()
-                override val singularValues: Point<Float64> get() = ejmlSvd.singularValues.asBuffer()
+                override val s: Matrix<Double> get() = ejmlSvd.getW(null).wrapMatrix()
+                override val v: Matrix<Double> get() = ejmlSvd.getV(null, false).wrapMatrix()
+                override val singularValues: Point<Double> get() = ejmlSvd.singularValues.asBuffer()

            }

-            QR -> object : QRDecomposition<Float64> {
+            QR -> object : QRDecomposition<Double> {
                val ejmlQr by lazy { DecompositionFactory_DDRM.qr().apply { decompose(origin.copy()) } }
-                override val q: Matrix<Float64> get() = ejmlQr.getQ(null, false).wrapMatrix()
-                override val r: Matrix<Float64> get() = ejmlQr.getR(null, false).wrapMatrix()
+                override val q: Matrix<Double> get() = ejmlQr.getQ(null, false).wrapMatrix()
+                override val r: Matrix<Double> get() = ejmlQr.getR(null, false).wrapMatrix()
            }

-            Cholesky -> object : CholeskyDecomposition<Float64> {
-                override val l: Matrix<Float64> by lazy {
+            Cholesky -> object : CholeskyDecomposition<Double> {
+                override val l: Matrix<Double> by lazy {
                    val cholesky =
                        DecompositionFactory_DDRM.chol(structure.rowNum, true).apply { decompose(origin.copy()) }

@ -258,49 +247,20 @@ public object EjmlLinearSpaceDDRM : EjmlLinearSpace<Double, Float64Field, DMatri
                }
            }

-            LUP -> object : LupDecomposition<Float64> {
+            LUP -> object : LupDecomposition<Double> {
                private val lup by lazy {
                    DecompositionFactory_DDRM.lu(origin.numRows, origin.numCols).apply { decompose(origin.copy()) }
                }

-                override val l: Matrix<Float64>
+                override val l: Matrix<Double>
                    get() = lup.getLower(null).wrapMatrix().withAttribute(LowerTriangular)

-                override val u: Matrix<Float64>
+
+                override val u: Matrix<Double>
                    get() = lup.getUpper(null).wrapMatrix().withAttribute(UpperTriangular)
-
                override val pivot: IntBuffer get() = lup.getRowPivotV(null).asBuffer()
            }

-            EIG -> {
-                check(origin.numCols == origin.numRows) { "Eigenvalue decomposition requires symmetric matrix" }
-                object : EigenDecomposition<Float64> {
-                    val cmEigen: EigenDecomposition_F64<DMatrixRMaj> by lazy {
-                        DecompositionFactory_DDRM.eig(origin.numRows, true).apply { decompose(origin) }
-                    }
-
-                    override val v: Matrix<Float64> by lazy {
-                        val eigenvectors = List(origin.numRows) { cmEigen.getEigenVector(it) }.filterNotNull()
-                        buildMatrix(eigenvectors.size, origin.numCols) { row, column ->
-                            eigenvectors[row][column]
-                        }
-                    }
-
-                    override val d: Matrix<Float64> by lazy {
-                        val eigenvalues = List(origin.numRows) { cmEigen.getEigenvalue(it) }
-
-                        buildMatrix(origin.numRows, origin.numCols) { row, column ->
-                            when (row) {
-                                column -> eigenvalues[row].real
-                                column - 1 -> eigenvalues[row].imaginary
-                                column + 1 -> -eigenvalues[row].imaginary
-                                else -> 0.0
-                            }
-                        }
-                    }
-                }
-            }
-
            else -> null
        }

@ -315,7 +275,7 @@ public object EjmlLinearSpaceDDRM : EjmlLinearSpace<Double, Float64Field, DMatri
     * @param b n by p matrix.
     * @return the solution for *x* that is n by p.
     */
-    public fun solve(a: Matrix<Float64>, b: Matrix<Float64>): EjmlDoubleMatrix<DMatrixRMaj> {
+    public fun solve(a: Matrix<Double>, b: Matrix<Double>): EjmlDoubleMatrix<DMatrixRMaj> {
        val res = DMatrixRMaj(1, 1)
        CommonOps_DDRM.solve(DMatrixRMaj(a.toEjml().origin), DMatrixRMaj(b.toEjml().origin), res)
        return res.wrapMatrix()
@ -328,7 +288,7 @@ public object EjmlLinearSpaceDDRM : EjmlLinearSpace<Double, Float64Field, DMatri
     * @param b n by p vector.
     * @return the solution for *x* that is n by p.
     */
-    public fun solve(a: Matrix<Float64>, b: Point<Float64>): EjmlDoubleVector<DMatrixRMaj> {
+    public fun solve(a: Matrix<Double>, b: Point<Double>): EjmlDoubleVector<DMatrixRMaj> {
        val res = DMatrixRMaj(1, 1)
        CommonOps_DDRM.solve(DMatrixRMaj(a.toEjml().origin), DMatrixRMaj(b.toEjml().origin), res)
        return EjmlDoubleVector(res)
@ -474,7 +434,6 @@ public object EjmlLinearSpaceFDRM : EjmlLinearSpace<Float, Float32Field, FMatrix

    override fun Float.times(v: Point<Float>): EjmlFloatVector<FMatrixRMaj> = v * this

-    @OptIn(UnstableKMathAPI::class)
    override fun <V, A : StructureAttribute<V>> computeAttribute(structure: Structure2D<Float32>, attribute: A): V? {
        val origin = structure.toEjml().origin

@ -529,35 +488,6 @@ public object EjmlLinearSpaceFDRM : EjmlLinearSpace<Float, Float32Field, FMatrix
                override val pivot: IntBuffer get() = lup.getRowPivotV(null).asBuffer()
            }

-            EIG -> {
-                check(origin.numCols == origin.numRows) { "Eigenvalue decomposition requires symmetric matrix" }
-                object : EigenDecomposition<Float32> {
-                    val cmEigen: EigenDecomposition_F32<FMatrixRMaj> by lazy {
-                        DecompositionFactory_FDRM.eig(origin.numRows, true).apply { decompose(origin) }
-                    }
-
-                    override val v by lazy {
-                        val eigenvectors: List<FMatrixRMaj> = List(origin.numRows) { cmEigen.getEigenVector(it) }
-                        buildMatrix(origin.numRows, origin.numCols) { row, column ->
-                            eigenvectors[row][column]
-                        }
-                    }
-
-                    override val d: Matrix<Float32> by lazy {
-                        val eigenvalues = List(origin.numRows) { cmEigen.getEigenvalue(it) }
-
-                        buildMatrix(origin.numRows, origin.numCols) { row, column ->
-                            when (row) {
-                                column -> eigenvalues[row].real
-                                column - 1 -> eigenvalues[row].imaginary
-                                column + 1 -> -eigenvalues[row].imaginary
-                                else -> 0f
-                            }
-                        }
-                    }
-                }
-            }
-
            else -> null
        }

@ -603,16 +533,16 @@ public object EjmlLinearSpaceDSCC : EjmlLinearSpace<Double, Float64Field, DMatri
     */
    override val elementAlgebra: Float64Field get() = Float64Field

-    override val type: SafeType<Float64> get() = safeTypeOf()
+    override val type: SafeType<Double> get() = safeTypeOf()

    @Suppress("UNCHECKED_CAST")
-    override fun Matrix<Float64>.toEjml(): EjmlDoubleMatrix<DMatrixSparseCSC> = when {
+    override fun Matrix<Double>.toEjml(): EjmlDoubleMatrix<DMatrixSparseCSC> = when {
        this is EjmlDoubleMatrix<*> && origin is DMatrixSparseCSC -> this as EjmlDoubleMatrix<DMatrixSparseCSC>
        else -> buildMatrix(rowNum, colNum) { i, j -> get(i, j) }
    }

    @Suppress("UNCHECKED_CAST")
-    override fun Point<Float64>.toEjml(): EjmlDoubleVector<DMatrixSparseCSC> = when {
+    override fun Point<Double>.toEjml(): EjmlDoubleVector<DMatrixSparseCSC> = when {
        this is EjmlDoubleVector<*> && origin is DMatrixSparseCSC -> this as EjmlDoubleVector<DMatrixSparseCSC>
        else -> EjmlDoubleVector(DMatrixSparseCSC(size, 1).also {
            (0 until it.numRows).forEach { row -> it[row, 0] = get(row) }
@ -639,21 +569,21 @@ public object EjmlLinearSpaceDSCC : EjmlLinearSpace<Double, Float64Field, DMatri
    private fun <T : DMatrix> T.wrapMatrix() = EjmlDoubleMatrix(this)
    private fun <T : DMatrix> T.wrapVector() = EjmlDoubleVector(this)

-    override fun Matrix<Float64>.unaryMinus(): Matrix<Float64> = this * elementAlgebra { -one }
+    override fun Matrix<Double>.unaryMinus(): Matrix<Double> = this * elementAlgebra { -one }

-    override fun Matrix<Float64>.dot(other: Matrix<Float64>): EjmlDoubleMatrix<DMatrixSparseCSC> {
+    override fun Matrix<Double>.dot(other: Matrix<Double>): EjmlDoubleMatrix<DMatrixSparseCSC> {
        val out = DMatrixSparseCSC(1, 1)
        CommonOps_DSCC.mult(toEjml().origin, other.toEjml().origin, out)
        return out.wrapMatrix()
    }

-    override fun Matrix<Float64>.dot(vector: Point<Float64>): EjmlDoubleVector<DMatrixSparseCSC> {
+    override fun Matrix<Double>.dot(vector: Point<Double>): EjmlDoubleVector<DMatrixSparseCSC> {
        val out = DMatrixSparseCSC(1, 1)
        CommonOps_DSCC.mult(toEjml().origin, vector.toEjml().origin, out)
        return out.wrapVector()
    }

-    override operator fun Matrix<Float64>.minus(other: Matrix<Float64>): EjmlDoubleMatrix<DMatrixSparseCSC> {
+    override operator fun Matrix<Double>.minus(other: Matrix<Double>): EjmlDoubleMatrix<DMatrixSparseCSC> {
        val out = DMatrixSparseCSC(1, 1)

        CommonOps_DSCC.add(
@ -669,19 +599,19 @@ public object EjmlLinearSpaceDSCC : EjmlLinearSpace<Double, Float64Field, DMatri
        return out.wrapMatrix()
    }

-    override operator fun Matrix<Float64>.times(value: Double): EjmlDoubleMatrix<DMatrixSparseCSC> {
+    override operator fun Matrix<Double>.times(value: Double): EjmlDoubleMatrix<DMatrixSparseCSC> {
        val res = DMatrixSparseCSC(1, 1)
        CommonOps_DSCC.scale(value, toEjml().origin, res)
        return res.wrapMatrix()
    }

-    override fun Point<Float64>.unaryMinus(): EjmlDoubleVector<DMatrixSparseCSC> {
+    override fun Point<Double>.unaryMinus(): EjmlDoubleVector<DMatrixSparseCSC> {
        val res = DMatrixSparseCSC(1, 1)
        CommonOps_DSCC.changeSign(toEjml().origin, res)
        return res.wrapVector()
    }

-    override fun Matrix<Float64>.plus(other: Matrix<Float64>): EjmlDoubleMatrix<DMatrixSparseCSC> {
+    override fun Matrix<Double>.plus(other: Matrix<Double>): EjmlDoubleMatrix<DMatrixSparseCSC> {
        val out = DMatrixSparseCSC(1, 1)

        CommonOps_DSCC.add(
@ -697,7 +627,7 @@ public object EjmlLinearSpaceDSCC : EjmlLinearSpace<Double, Float64Field, DMatri
        return out.wrapMatrix()
    }

-    override fun Point<Float64>.plus(other: Point<Float64>): EjmlDoubleVector<DMatrixSparseCSC> {
+    override fun Point<Double>.plus(other: Point<Double>): EjmlDoubleVector<DMatrixSparseCSC> {
        val out = DMatrixSparseCSC(1, 1)

        CommonOps_DSCC.add(
@ -713,7 +643,7 @@ public object EjmlLinearSpaceDSCC : EjmlLinearSpace<Double, Float64Field, DMatri
        return out.wrapVector()
    }

-    override fun Point<Float64>.minus(other: Point<Float64>): EjmlDoubleVector<DMatrixSparseCSC> {
+    override fun Point<Double>.minus(other: Point<Double>): EjmlDoubleVector<DMatrixSparseCSC> {
        val out = DMatrixSparseCSC(1, 1)

        CommonOps_DSCC.add(
@ -729,17 +659,17 @@ public object EjmlLinearSpaceDSCC : EjmlLinearSpace<Double, Float64Field, DMatri
        return out.wrapVector()
    }

-    override fun Double.times(m: Matrix<Float64>): EjmlDoubleMatrix<DMatrixSparseCSC> = m * this
+    override fun Double.times(m: Matrix<Double>): EjmlDoubleMatrix<DMatrixSparseCSC> = m * this

-    override fun Point<Float64>.times(value: Double): EjmlDoubleVector<DMatrixSparseCSC> {
+    override fun Point<Double>.times(value: Double): EjmlDoubleVector<DMatrixSparseCSC> {
        val res = DMatrixSparseCSC(1, 1)
        CommonOps_DSCC.scale(value, toEjml().origin, res)
        return res.wrapVector()
    }

-    override fun Double.times(v: Point<Float64>): EjmlDoubleVector<DMatrixSparseCSC> = v * this
+    override fun Double.times(v: Point<Double>): EjmlDoubleVector<DMatrixSparseCSC> = v * this

-    override fun <V, A : StructureAttribute<V>> computeAttribute(structure: Structure2D<Float64>, attribute: A): V? {
+    override fun <V, A : StructureAttribute<V>> computeAttribute(structure: Structure2D<Double>, attribute: A): V? {
        val origin = structure.toEjml().origin

        val raw: Any? = when (attribute) {
@ -751,16 +681,16 @@ public object EjmlLinearSpaceDSCC : EjmlLinearSpace<Double, Float64Field, DMatri

            Determinant -> CommonOps_DSCC.det(origin)

-            QR -> object : QRDecomposition<Float64> {
+            QR -> object : QRDecomposition<Double> {
                val ejmlQr by lazy {
                    DecompositionFactory_DSCC.qr(FillReducing.NONE).apply { decompose(origin.copy()) }
                }
-                override val q: Matrix<Float64> get() = ejmlQr.getQ(null, false).wrapMatrix()
-                override val r: Matrix<Float64> get() = ejmlQr.getR(null, false).wrapMatrix()
+                override val q: Matrix<Double> get() = ejmlQr.getQ(null, false).wrapMatrix()
+                override val r: Matrix<Double> get() = ejmlQr.getR(null, false).wrapMatrix()
            }

-            Cholesky -> object : CholeskyDecomposition<Float64> {
-                override val l: Matrix<Float64> by lazy {
+            Cholesky -> object : CholeskyDecomposition<Double> {
+                override val l: Matrix<Double> by lazy {
                    val cholesky =
                        DecompositionFactory_DSCC.cholesky().apply { decompose(origin.copy()) }

@ -768,16 +698,16 @@ public object EjmlLinearSpaceDSCC : EjmlLinearSpace<Double, Float64Field, DMatri
                }
            }

-            LUP -> object : LupDecomposition<Float64> {
+            LUP -> object : LupDecomposition<Double> {
                private val lup by lazy {
                    DecompositionFactory_DSCC.lu(FillReducing.NONE).apply { decompose(origin.copy()) }
                }

-                override val l: Matrix<Float64>
+                override val l: Matrix<Double>
                    get() = lup.getLower(null).wrapMatrix().withAttribute(LowerTriangular)


-                override val u: Matrix<Float64>
+                override val u: Matrix<Double>
                    get() = lup.getUpper(null).wrapMatrix().withAttribute(UpperTriangular)
                override val pivot: IntBuffer get() = lup.getRowPivotV(null).asBuffer()
            }
@ -796,7 +726,7 @@ public object EjmlLinearSpaceDSCC : EjmlLinearSpace<Double, Float64Field, DMatri
     * @param b n by p matrix.
     * @return the solution for *x* that is n by p.
     */
-    public fun solve(a: Matrix<Float64>, b: Matrix<Float64>): EjmlDoubleMatrix<DMatrixSparseCSC> {
+    public fun solve(a: Matrix<Double>, b: Matrix<Double>): EjmlDoubleMatrix<DMatrixSparseCSC> {
        val res = DMatrixSparseCSC(1, 1)
        CommonOps_DSCC.solve(DMatrixSparseCSC(a.toEjml().origin), DMatrixSparseCSC(b.toEjml().origin), res)
        return res.wrapMatrix()
@ -809,7 +739,7 @@ public object EjmlLinearSpaceDSCC : EjmlLinearSpace<Double, Float64Field, DMatri
     * @param b n by p vector.
     * @return the solution for *x* that is n by p.
     */
-    public fun solve(a: Matrix<Float64>, b: Point<Float64>): EjmlDoubleVector<DMatrixSparseCSC> {
+    public fun solve(a: Matrix<Double>, b: Point<Double>): EjmlDoubleVector<DMatrixSparseCSC> {
        val res = DMatrixSparseCSC(1, 1)
        CommonOps_DSCC.solve(DMatrixSparseCSC(a.toEjml().origin), DMatrixSparseCSC(b.toEjml().origin), res)
        return EjmlDoubleVector(res)
--- a/kmath-ejml/src/jvmTest/kotlin/space/kscience/kmath/ejml/EjmlMatrixTest.kt
+++ b/kmath-ejml/src/jvmTest/kotlin/space/kscience/kmath/ejml/EjmlMatrixTest.kt
@ -17,16 +17,12 @@ import space.kscience.kmath.linear.*
 import space.kscience.kmath.nd.StructureND
 import space.kscience.kmath.nd.toArray
 import space.kscience.kmath.operations.algebra
-import space.kscience.kmath.structures.Float64
-import space.kscience.kmath.testutils.assertStructureEquals
 import kotlin.random.Random
 import kotlin.random.asJavaRandom
 import kotlin.test.*

 internal fun <T : Any> assertMatrixEquals(expected: StructureND<T>, actual: StructureND<T>) {
-    expected.elements().forEach { (index, value) ->
-        assertEquals(value, actual[index], "Structure element with index ${index.toList()} should be equal to $value but is ${actual[index]}")
-    }
+    assertTrue { StructureND.contentEquals(expected, actual) }
 }

@OptIn(UnstableKMathAPI::class)
@ -67,7 +63,7 @@ internal class EjmlMatrixTest {
        val w = EjmlDoubleMatrix(m)
        val det: Double = w.getOrComputeAttribute(Determinant) ?: fail()
        assertEquals(CommonOps_DDRM.det(m), det)
-        val lup: LupDecomposition<Float64> = w.getOrComputeAttribute(LUP) ?: fail()
+        val lup: LupDecomposition<Double> = w.getOrComputeAttribute(LUP) ?: fail()

        val ludecompositionF64 = DecompositionFactory_DDRM.lu(m.numRows, m.numCols)
            .also { it.decompose(m.copy()) }
@ -108,15 +104,4 @@ internal class EjmlMatrixTest {

        assertTrue { StructureND.contentEquals(one(dim, dim), res, 1e-3) }
    }
-
-    @Test
-    fun eigenValueDecomposition() = EjmlLinearSpaceDDRM {
-        val dim = 46
-        val u = buildMatrix(dim, dim) { i, j -> if (i <= j) random.nextDouble() else 0.0 }
-        val matrix = buildMatrix(dim, dim) { row, col ->
-            if (row >= col) u[row, col] else u[col, row]
-        }
-        val eigen = matrix.getOrComputeAttribute(EIG) ?: fail()
-        assertStructureEquals(matrix, eigen.v dot eigen.d dot eigen.v.transposed())
-    }
 }
--- a/kmath-ejml/src/jvmTest/kotlin/space/kscience/kmath/ejml/EjmlVectorTest.kt
+++ b/kmath-ejml/src/jvmTest/kotlin/space/kscience/kmath/ejml/EjmlVectorTest.kt
--- a/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/DoubleVector.kt
+++ b/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/DoubleVector.kt
@ -9,13 +9,12 @@ import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.linear.Point
 import space.kscience.kmath.operations.Float64L2Norm
 import space.kscience.kmath.structures.Buffer
-import space.kscience.kmath.structures.Float64
 import space.kscience.kmath.structures.MutableBuffer.Companion.double
 import space.kscience.kmath.structures.asBuffer
 import space.kscience.kmath.structures.indices
 import kotlin.math.pow

-public typealias DoubleVector = Point<Float64>
+public typealias DoubleVector = Point<Double>

 public fun DoubleVector(vararg doubles: Double): DoubleVector = doubles.asBuffer()

@ -42,7 +41,7 @@ public operator fun DoubleVector.plus(number: Number): DoubleVector = map { it +

 public operator fun Number.plus(vector: DoubleVector): DoubleVector = vector + this

-public operator fun DoubleVector.unaryMinus(): Buffer<Float64> = map { -it }
+public operator fun DoubleVector.unaryMinus(): Buffer<Double> = map { -it }

 public operator fun DoubleVector.minus(other: DoubleVector): DoubleVector {
    require(size == other.size) { "Vector size $size expected but ${other.size} found" }
--- a/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/RealMatrix.kt
+++ b/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/RealMatrix.kt
@ -15,7 +15,6 @@ import space.kscience.kmath.operations.Float64Field
 import space.kscience.kmath.operations.algebra
 import space.kscience.kmath.operations.asIterable
 import space.kscience.kmath.structures.Buffer
-import space.kscience.kmath.structures.Float64
 import space.kscience.kmath.structures.Float64Buffer
 import kotlin.math.pow

@ -31,7 +30,7 @@ import kotlin.math.pow
 *  Functions that help create a real (Double) matrix
 */

-public typealias RealMatrix = Matrix<Float64>
+public typealias RealMatrix = Matrix<Double>

 public fun realMatrix(rowNum: Int, colNum: Int, initializer: Float64Field.(i: Int, j: Int) -> Double): RealMatrix =
    Double.algebra.linearSpace.buildMatrix(rowNum, colNum, initializer)
@ -115,7 +114,7 @@ public operator fun RealMatrix.minus(other: RealMatrix): RealMatrix =
 *  Operations on columns
 */

-public inline fun RealMatrix.appendColumn(crossinline mapper: (Buffer<Float64>) -> Double): RealMatrix =
+public inline fun RealMatrix.appendColumn(crossinline mapper: (Buffer<Double>) -> Double): RealMatrix =
    Double.algebra.linearSpace.buildMatrix(rowNum, colNum + 1) { row, col ->
        if (col < colNum)
            get(row, col)
--- a/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/dot.kt
+++ b/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/dot.kt
@ -8,12 +8,11 @@ package space.kscience.kmath.real
 import space.kscience.kmath.linear.Matrix
 import space.kscience.kmath.linear.linearSpace
 import space.kscience.kmath.operations.algebra
-import space.kscience.kmath.structures.Float64


 /**
 * Optimized dot product for real matrices
 */
-public infix fun Matrix<Float64>.dot(other: Matrix<Float64>): Matrix<Float64> = Double.algebra.linearSpace.run {
+public infix fun Matrix<Double>.dot(other: Matrix<Double>): Matrix<Double> = Double.algebra.linearSpace.run {
    this@dot dot other
 }
--- a/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/grids.kt
+++ b/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/grids.kt
@ -7,17 +7,16 @@ package space.kscience.kmath.real

 import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.structures.Buffer
-import space.kscience.kmath.structures.Float64
 import space.kscience.kmath.structures.Float64Buffer
 import kotlin.math.floor

-public val ClosedFloatingPointRange<Float64>.length: Double get() = endInclusive - start
+public val ClosedFloatingPointRange<Double>.length: Double get() = endInclusive - start

 /**
 * Create a Buffer-based grid with equally distributed [numberOfPoints] points. The range could be increasing or  decreasing.
 * If range has a zero size, then the buffer consisting of [numberOfPoints] equal values is returned.
 */
-public fun Buffer.Companion.fromRange(range: ClosedFloatingPointRange<Float64>, numberOfPoints: Int): Float64Buffer {
+public fun Buffer.Companion.fromRange(range: ClosedFloatingPointRange<Double>, numberOfPoints: Int): Float64Buffer {
    require(numberOfPoints >= 2) { "Number of points in grid must be more than 1" }
    val normalizedRange = when {
        range.endInclusive > range.start -> range
@ -32,7 +31,7 @@ public fun Buffer.Companion.fromRange(range: ClosedFloatingPointRange<Float64>,
 * Create a Buffer-based grid with equally distributed points with a fixed [step]. The range could be increasing or  decreasing.
 * If the step is larger than the range size, single point is returned.
 */
-public fun Buffer.Companion.withFixedStep(range: ClosedFloatingPointRange<Float64>, step: Double): Float64Buffer {
+public fun Buffer.Companion.withFixedStep(range: ClosedFloatingPointRange<Double>, step: Double): Float64Buffer {
    require(step > 0) { "The grid step must be positive" }
    val normalizedRange = when {
        range.endInclusive > range.start -> range
@ -52,4 +51,4 @@ public fun Buffer.Companion.withFixedStep(range: ClosedFloatingPointRange<Float6
 * If step is negative, the same goes from upper boundary downwards
 */
@UnstableKMathAPI
-public infix fun ClosedFloatingPointRange<Float64>.step(step: Double): Float64Buffer = Buffer.withFixedStep(this, step)
+public infix fun ClosedFloatingPointRange<Double>.step(step: Double): Float64Buffer = Buffer.withFixedStep(this, step)
--- a/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/realND.kt
+++ b/kmath-for-real/src/commonMain/kotlin/space/kscience/kmath/real/realND.kt
@ -7,13 +7,12 @@ package space.kscience.kmath.real

 import space.kscience.kmath.nd.BufferND
 import space.kscience.kmath.operations.Float64Field
-import space.kscience.kmath.structures.Float64
 import space.kscience.kmath.structures.Float64Buffer

 /**
 * Map one [BufferND] using function without indices.
 */
-public inline fun BufferND<Float64>.mapInline(crossinline transform: Float64Field.(Double) -> Double): BufferND<Float64> {
+public inline fun BufferND<Double>.mapInline(crossinline transform: Float64Field.(Double) -> Double): BufferND<Double> {
    val array = DoubleArray(indices.linearSize) { offset -> Float64Field.transform(buffer[offset]) }
    return BufferND(indices, Float64Buffer(array))
 }
@ -21,7 +20,7 @@ public inline fun BufferND<Float64>.mapInline(crossinline transform: Float64Fiel
 /**
 * Element by element application of any operation on elements to the whole array. Just like in numpy.
 */
-public operator fun Function1<Double, Double>.invoke(elementND: BufferND<Float64>): BufferND<Float64> =
+public operator fun Function1<Double, Double>.invoke(elementND: BufferND<Double>): BufferND<Double> =
    elementND.mapInline { this@invoke(it) }

 /* plus and minus */
@ -29,9 +28,9 @@ public operator fun Function1<Double, Double>.invoke(elementND: BufferND<Float64
 /**
 * Summation operation for [BufferND] and single element
 */
-public operator fun BufferND<Float64>.plus(arg: Double): BufferND<Float64> = mapInline { it + arg }
+public operator fun BufferND<Double>.plus(arg: Double): BufferND<Double> = mapInline { it + arg }

 /**
 * Subtraction operation between [BufferND] and single element
 */
-public operator fun BufferND<Float64>.minus(arg: Double): BufferND<Float64> = mapInline { it - arg }
+public operator fun BufferND<Double>.minus(arg: Double): BufferND<Double> = mapInline { it - arg }
--- a/kmath-for-real/src/commonTest/kotlin/space/kscience/kmath/real/DoubleMatrixTest.kt
+++ b/kmath-for-real/src/commonTest/kotlin/space/kscience/kmath/real/DoubleMatrixTest.kt
@ -170,7 +170,7 @@ internal class DoubleMatrixTest {
        assertEquals(matrix1.average(), 1.375)
    }

-//    fun printMatrix(m: Matrix<Float64>) {
+//    fun printMatrix(m: Matrix<Double>) {
 //        for (row in 0 until m.shape[0]) {
 //            for (col in 0 until m.shape[1]) {
 //                print(m[row, col])
--- a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/polynomialUtil.kt
+++ b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/polynomialUtil.kt
@ -7,7 +7,6 @@ package space.kscience.kmath.functions

 import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.operations.*
-import space.kscience.kmath.structures.Float64
 import kotlin.contracts.InvocationKind
 import kotlin.contracts.contract
 import kotlin.math.max
@ -32,7 +31,7 @@ public inline fun <C, A, R> A.polynomialSpace(block: PolynomialSpace<C, A>.() ->
 /**
 * Evaluates value of [this] Double polynomial on provided Double argument.
 */
-public fun Polynomial<Float64>.value(arg: Double): Double =
+public fun Polynomial<Double>.value(arg: Double): Double =
    coefficients.reduceIndexedOrNull { index, acc, c ->
        acc + c * arg.pow(index)
    } ?: .0
--- a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/integration/GaussIntegrator.kt
+++ b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/integration/GaussIntegrator.kt
@ -8,7 +8,6 @@ import space.kscience.attributes.AttributesBuilder
 import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.operations.Field
 import space.kscience.kmath.structures.Buffer
-import space.kscience.kmath.structures.Float64
 import space.kscience.kmath.structures.asBuffer
 import space.kscience.kmath.structures.indices

@ -28,7 +27,7 @@ public class GaussIntegrator<T : Any>(
    public val algebra: Field<T>,
 ) : UnivariateIntegrator<T> {

-    private fun buildRule(integrand: UnivariateIntegrand<T>): Pair<Buffer<Float64>, Buffer<Float64>> {
+    private fun buildRule(integrand: UnivariateIntegrand<T>): Pair<Buffer<Double>, Buffer<Double>> {
        val factory = integrand[GaussIntegratorRuleFactory] ?: GaussLegendreRuleFactory
        val predefinedRanges = integrand[UnivariateIntegrandRanges]
        if (predefinedRanges == null || predefinedRanges.ranges.isEmpty()) {
@ -90,7 +89,7 @@ public val <T : Any> Field<T>.gaussIntegrator: GaussIntegrator<T> get() = GaussI
 */
@UnstableKMathAPI
 public inline fun <reified T : Any> GaussIntegrator<T>.integrate(
-    range: ClosedRange<Float64>,
+    range: ClosedRange<Double>,
    order: Int = 10,
    intervals: Int = 10,
    noinline attributesBuilder: AttributesBuilder<UnivariateIntegrand<T>>.() -> Unit = {},
--- a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/integration/GaussIntegratorRuleFactory.kt
+++ b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/integration/GaussIntegratorRuleFactory.kt
@ -8,17 +8,16 @@ package space.kscience.kmath.integration
 import space.kscience.kmath.operations.Float64Field
 import space.kscience.kmath.operations.mapToBuffer
 import space.kscience.kmath.structures.Buffer
-import space.kscience.kmath.structures.Float64
 import space.kscience.kmath.structures.Float64Buffer
 import space.kscience.kmath.structures.asBuffer
 import kotlin.math.ulp
 import kotlin.native.concurrent.ThreadLocal

 public interface GaussIntegratorRuleFactory {
-    public fun build(numPoints: Int): Pair<Buffer<Float64>, Buffer<Float64>>
+    public fun build(numPoints: Int): Pair<Buffer<Double>, Buffer<Double>>

    public companion object : IntegrandAttribute<GaussIntegratorRuleFactory> {
-        public fun double(numPoints: Int, range: ClosedRange<Float64>): Pair<Buffer<Float64>, Buffer<Float64>> =
+        public fun double(numPoints: Int, range: ClosedRange<Double>): Pair<Buffer<Double>, Buffer<Double>> =
            GaussLegendreRuleFactory.build(numPoints, range)
    }
 }
@ -29,9 +28,9 @@ public interface GaussIntegratorRuleFactory {
 */
 public fun GaussIntegratorRuleFactory.build(
    numPoints: Int,
-    range: ClosedRange<Float64>,
-): Pair<Buffer<Float64>, Buffer<Float64>> {
-    val normalized: Pair<Buffer<Float64>, Buffer<Float64>> = build(numPoints)
+    range: ClosedRange<Double>,
+): Pair<Buffer<Double>, Buffer<Double>> {
+    val normalized: Pair<Buffer<Double>, Buffer<Double>> = build(numPoints)
    val length = range.endInclusive - range.start

    val points = normalized.first.mapToBuffer(Float64Field.bufferFactory) {
@ -56,13 +55,13 @@ public fun GaussIntegratorRuleFactory.build(
@ThreadLocal
 public object GaussLegendreRuleFactory : GaussIntegratorRuleFactory {

-    private val cache = HashMap<Int, Pair<Buffer<Float64>, Buffer<Float64>>>()
+    private val cache = HashMap<Int, Pair<Buffer<Double>, Buffer<Double>>>()

-    private fun getOrBuildRule(numPoints: Int): Pair<Buffer<Float64>, Buffer<Float64>> =
+    private fun getOrBuildRule(numPoints: Int): Pair<Buffer<Double>, Buffer<Double>> =
        cache.getOrPut(numPoints) { buildRule(numPoints) }


-    private fun buildRule(numPoints: Int): Pair<Buffer<Float64>, Buffer<Float64>> {
+    private fun buildRule(numPoints: Int): Pair<Buffer<Double>, Buffer<Double>> {
        if (numPoints == 1) {
            // Break recursion.
            return Pair(
@ -74,7 +73,7 @@ public object GaussLegendreRuleFactory : GaussIntegratorRuleFactory {
        // Get previous rule.
        // If it has not been computed, yet it will trigger a recursive call
        // to this method.
-        val previousPoints: Buffer<Float64> = getOrBuildRule(numPoints - 1).first
+        val previousPoints: Buffer<Double> = getOrBuildRule(numPoints - 1).first

        // Compute next rule.
        val points = DoubleArray(numPoints)
@ -163,7 +162,7 @@ public object GaussLegendreRuleFactory : GaussIntegratorRuleFactory {
        return Pair(points.asBuffer(), weights.asBuffer())
    }

-    override fun build(numPoints: Int): Pair<Buffer<Float64>, Buffer<Float64>> = getOrBuildRule(numPoints)
+    override fun build(numPoints: Int): Pair<Buffer<Double>, Buffer<Double>> = getOrBuildRule(numPoints)

    override fun toString(): String = "GaussLegendreRule"
 }
--- a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/integration/Integrand.kt
+++ b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/integration/Integrand.kt
@ -6,7 +6,6 @@
 package space.kscience.kmath.integration

 import space.kscience.attributes.*
-import space.kscience.kmath.structures.Float64

 public interface IntegrandAttribute<T> : Attribute<T>

@ -45,9 +44,9 @@ public inline val <reified T : Any> Integrand<T>.valueOrNull: T? get() = attribu
 */
 public inline val <reified T : Any> Integrand<T>.value: T get() = valueOrNull ?: error("No value in the integrand")

-public object IntegrandRelativeAccuracy : IntegrandAttribute<Float64>
+public object IntegrandRelativeAccuracy : IntegrandAttribute<Double>

-public object IntegrandAbsoluteAccuracy : IntegrandAttribute<Float64>
+public object IntegrandAbsoluteAccuracy : IntegrandAttribute<Double>

 public object IntegrandCallsPerformed : IntegrandAttribute<Int>

--- a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/integration/SimpsonIntegrator.kt
+++ b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/integration/SimpsonIntegrator.kt
@ -10,7 +10,6 @@ import space.kscience.kmath.operations.Field
 import space.kscience.kmath.operations.Float64Field
 import space.kscience.kmath.operations.invoke
 import space.kscience.kmath.operations.sum
-import space.kscience.kmath.structures.Float64

 /**
 * Use double pass Simpson rule integration with a fixed number of points.
@ -25,7 +24,7 @@ public class SimpsonIntegrator<T : Any>(
 ) : UnivariateIntegrator<T> {

    private fun integrateRange(
-        integrand: UnivariateIntegrand<T>, range: ClosedRange<Float64>, numPoints: Int,
+        integrand: UnivariateIntegrand<T>, range: ClosedRange<Double>, numPoints: Int,
    ): T = algebra {
        val h: Double = (range.endInclusive - range.start) / (numPoints - 1)
        val values: List<T> = List(numPoints) { i ->
@ -76,9 +75,9 @@ public val <T : Any> Field<T>.simpsonIntegrator: SimpsonIntegrator<T> get() = Si
 * * [IntegrandMaxCalls]&mdash;the maximum number of function calls during integration. For non-iterative rules, always uses
 * the maximum number of points. By default, uses 10 points.
 */
-public object DoubleSimpsonIntegrator : UnivariateIntegrator<Float64> {
+public object DoubleSimpsonIntegrator : UnivariateIntegrator<Double> {
    private fun integrateRange(
-        integrand: UnivariateIntegrand<Float64>, range: ClosedRange<Float64>, numPoints: Int,
+        integrand: UnivariateIntegrand<Double>, range: ClosedRange<Double>, numPoints: Int,
    ): Double {
        val h: Double = (range.endInclusive - range.start) / (numPoints - 1)
        val values = DoubleArray(numPoints) { i ->
@ -97,7 +96,7 @@ public object DoubleSimpsonIntegrator : UnivariateIntegrator<Float64> {
        return res
    }

-    override fun integrate(integrand: UnivariateIntegrand<Float64>): UnivariateIntegrand<Float64> {
+    override fun integrate(integrand: UnivariateIntegrand<Double>): UnivariateIntegrand<Double> {
        val ranges = integrand[UnivariateIntegrandRanges]
        return if (ranges != null) {
            val res = ranges.ranges.sumOf { integrateRange(integrand, it.first, it.second) }
--- a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/integration/SplineIntegrator.kt
+++ b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/integration/SplineIntegrator.kt
@ -14,7 +14,6 @@ import space.kscience.kmath.interpolation.SplineInterpolator
 import space.kscience.kmath.interpolation.interpolatePolynomials
 import space.kscience.kmath.operations.*
 import space.kscience.kmath.structures.Buffer
-import space.kscience.kmath.structures.Float64
 import space.kscience.kmath.structures.Float64Buffer
 import space.kscience.kmath.structures.MutableBufferFactory

@ -60,7 +59,7 @@ public class SplineIntegrator<T : Comparable<T>>(

        val interpolator: PolynomialInterpolator<T> = SplineInterpolator(algebra, bufferFactory)

-        val nodes: Buffer<Float64> = integrand[UnivariateIntegrationNodes] ?: run {
+        val nodes: Buffer<Double> = integrand[UnivariateIntegrationNodes] ?: run {
            val numPoints = integrand[IntegrandMaxCalls] ?: 100
            val step = (range.endInclusive - range.start) / (numPoints - 1)
            Float64Buffer(numPoints) { i -> range.start + i * step }
@ -86,12 +85,12 @@ public class SplineIntegrator<T : Comparable<T>>(
 * uses the maximum number of points. By default, uses 10 points.
 */
@UnstableKMathAPI
-public object DoubleSplineIntegrator : UnivariateIntegrator<Float64> {
-    override fun integrate(integrand: UnivariateIntegrand<Float64>): UnivariateIntegrand<Float64> {
+public object DoubleSplineIntegrator : UnivariateIntegrator<Double> {
+    override fun integrate(integrand: UnivariateIntegrand<Double>): UnivariateIntegrand<Double> {
        val range = integrand[IntegrationRange] ?: 0.0..1.0
-        val interpolator: PolynomialInterpolator<Float64> = SplineInterpolator(Float64Field, Float64Field.bufferFactory)
+        val interpolator: PolynomialInterpolator<Double> = SplineInterpolator(Float64Field, Float64Field.bufferFactory)

-        val nodes: Buffer<Float64> = integrand[UnivariateIntegrationNodes] ?: run {
+        val nodes: Buffer<Double> = integrand[UnivariateIntegrationNodes] ?: run {
            val numPoints = integrand[IntegrandMaxCalls] ?: 100
            val step = (range.endInclusive - range.start) / (numPoints - 1)
            Float64Buffer(numPoints) { i -> range.start + i * step }
@ -109,5 +108,5 @@ public object DoubleSplineIntegrator : UnivariateIntegrator<Float64> {

@Suppress("unused")
@UnstableKMathAPI
-public inline val Float64Field.splineIntegrator: UnivariateIntegrator<Float64>
+public inline val Float64Field.splineIntegrator: UnivariateIntegrator<Double>
    get() = DoubleSplineIntegrator
--- a/Show More
+++ b/Show More