Merge remote-tracking branch 'origin/dev' into dev

# Conflicts:
#	kmath-core/api/kmath-core.api
#	kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixContext.kt

examples/build.gradle.kts

@@ -1,7 +1,6 @@
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
-    java
     kotlin("jvm")
     kotlin("plugin.allopen")
     id("kotlinx.benchmark")

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

@@ -1,5 +1,6 @@
 package space.kscience.kmath.linear
 
+import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.operations.Ring
 import space.kscience.kmath.operations.SpaceOperations
 import space.kscience.kmath.operations.invoke
@@ -7,6 +8,7 @@ import space.kscience.kmath.operations.sum
 import space.kscience.kmath.structures.Buffer
 import space.kscience.kmath.structures.BufferFactory
 import space.kscience.kmath.structures.asSequence
+import kotlin.reflect.KClass
 
 /**
  * Basic operations on matrices. Operates on [Matrix].
@@ -16,12 +18,12 @@ import space.kscience.kmath.structures.asSequence
  */
 public interface MatrixContext<T : Any, out M : Matrix<T>> : SpaceOperations<Matrix<T>> {
     /**
-     * Produce a matrix with this context and given dimensions
+     * Produces a matrix with this context and given dimensions.
      */
     public fun produce(rows: Int, columns: Int, initializer: (i: Int, j: Int) -> T): M
 
     /**
-     * Produce a point compatible with matrix space (and possibly optimized for it)
+     * Produces a point compatible with matrix space (and possibly optimized for it).
      */
     public fun point(size: Int, initializer: (Int) -> T): Point<T> = Buffer.boxing(size, initializer)
 
@@ -63,11 +65,23 @@ public interface MatrixContext<T : Any, out M : Matrix<T>> : SpaceOperations<Mat
      * Multiplies an element by a matrix of it.
      *
      * @receiver the multiplicand.
-     * @param value the multiplier.
+     * @param m the multiplier.
      * @receiver the product.
      */
     public operator fun T.times(m: Matrix<T>): M = m * this
 
+    /**
+     * Gets a feature from the matrix. This function may return some additional features to
+     * [kscience.kmath.nd.NDStructure.getFeature].
+     *
+     * @param F the type of feature.
+     * @param m the matrix.
+     * @param type the [KClass] instance of [F].
+     * @return a feature object or `null` if it isn't present.
+     */
+    @UnstableKMathAPI
+    public fun <F : Any> getFeature(m: Matrix<T>, type: KClass<F>): F? = m.getFeature(type)
+
     public companion object {
 
         /**
@@ -86,6 +100,21 @@ public interface MatrixContext<T : Any, out M : Matrix<T>> : SpaceOperations<Mat
     }
 }
 
+/**
+ * Gets a feature from the matrix. This function may return some additional features to
+ * [kscience.kmath.nd.NDStructure.getFeature].
+ *
+ * @param T the type of items in the matrices.
+ * @param M the type of operated matrices.
+ * @param F the type of feature.
+ * @receiver the [MatrixContext] of [T].
+ * @param m the matrix.
+ * @return a feature object or `null` if it isn't present.
+ */
+@UnstableKMathAPI
+public inline fun <T : Any, reified F : Any> MatrixContext<T, *>.getFeature(m: Matrix<T>): F? =
+    getFeature(m, F::class)
+
 /**
  * Partial implementation of [MatrixContext] for matrices of [Ring].
  *

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

@@ -237,11 +237,22 @@ public class ArrayBuffer<T>(private val array: Array<T>) : MutableBuffer<T> {
     override fun copy(): MutableBuffer<T> = ArrayBuffer(array.copyOf())
 }
 
+
 /**
  * Returns an [ArrayBuffer] that wraps the original array.
  */
 public fun <T> Array<T>.asBuffer(): ArrayBuffer<T> = ArrayBuffer(this)
 
+/**
+ * Creates a new [ArrayBuffer] with the specified [size], where each element is calculated by calling the specified
+ * [init] function.
+ *
+ * The function [init] is called for each array element sequentially starting from the first one.
+ * It should return the value for an array element given its index.
+ */
+public inline fun <reified T> ArrayBuffer(size: Int, init: (Int) -> T): ArrayBuffer<T> =
+    Array(size) { i -> init(i) }.asBuffer()
+
 /**
  * Immutable wrapper for [MutableBuffer].
  *

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

@@ -31,8 +31,8 @@ public object EjmlMatrixContext : MatrixContext<Double, EjmlMatrix> {
 
     override fun produce(rows: Int, columns: Int, initializer: (i: Int, j: Int) -> Double): EjmlMatrix =
         EjmlMatrix(SimpleMatrix(rows, columns).also {
-            (0 until it.numRows()).forEach { row ->
+            (0 until rows).forEach { row ->
-                (0 until it.numCols()).forEach { col -> it[row, col] = initializer(row, col) }
+                (0 until columns).forEach { col -> it[row, col] = initializer(row, col) }
             }
         })
 

kmath-stat/build.gradle.kts

@@ -7,6 +7,7 @@ kotlin.sourceSets {
         languageSettings.apply {
             useExperimentalAnnotation("kotlinx.coroutines.FlowPreview")
             useExperimentalAnnotation("kotlinx.coroutines.ExperimentalCoroutinesApi")
+            useExperimentalAnnotation("kotlinx.coroutines.ObsoleteCoroutinesApi")
         }
     }