Merge branch 'v0.0.2' into multiplatform

gradle.properties

@@ -2,4 +2,4 @@ kotlin.code.style=official
 kotlin.mpp.enableGranularSourceSetsMetadata=true
 kotlin.native.enableDependencyPropagation=false
 systemProp.kotlinVersion=1.4.32
-multikVersion=0.0.1-SNAPSHOT
+multikVersion=0.0.2-SNAPSHOT

multik-api/src/commonMain/kotlin/org/jetbrains/kotlinx/multik/api/LinAlg.kt

@@ -22,6 +22,8 @@ public interface LinAlg {
      */
     public fun <T : Number> norm(mat: MultiArray<T, D2>, p: Int = 2): Double
 
+    public fun <T : Number, D: Dim2> solve(a: MultiArray<T, D2>, b: MultiArray<T, D>): NDArray<T, D>
+
     /**
      * Dot products of two arrays. Matrix product.
      */

multik-api/src/commonMain/kotlin/org/jetbrains/kotlinx/multik/ndarray/data/Internals.kt

@@ -4,8 +4,6 @@
 
 package org.jetbrains.kotlinx.multik.ndarray.data
 
-import org.jetbrains.kotlinx.multik.ndarray.operations.minus
-
 @PublishedApi
 @Suppress("NOTHING_TO_INLINE")
 internal inline fun requireDimension(dim: Dimension, shapeSize: Int) {
@@ -77,7 +75,17 @@ internal inline fun <reified T : Number> Number.toPrimitiveType(): T = when (T::
 } as T
 
 //TODO(create module utils)
-/*internal*/ public operator fun <T : Number> Number.compareTo(other: T): Int = (this - other).toInt()
+public operator fun <T : Number> Number.compareTo(other: T): Int {
+    return when {
+        this is Float && other is Float -> this.compareTo(other)
+        this is Double && other is Double -> this.compareTo(other)
+        this is Int && other is Int -> this.compareTo(other)
+        this is Long && other is Long -> this.compareTo(other)
+        this is Short && other is Short -> this.compareTo(other)
+        this is Byte && other is Byte -> this.compareTo(other)
+        else -> this.toDouble().compareTo(other.toDouble())
+    }
+}
 
 @PublishedApi
 internal fun IntArray.remove(pos: Int): IntArray = when (pos) {

multik-api/src/commonMain/kotlin/org/jetbrains/kotlinx/multik/ndarray/data/Slice.kt

@@ -9,51 +9,93 @@ package org.jetbrains.kotlinx.multik.ndarray.data
  */
 public interface Indexing
 
+/**
+ * Convenient Slice for start stub.
+ */
+public class SliceStartStub
+
+/**
+ * Convenient Slice for stop stub.
+ */
+public class SliceEndStub
+
+/**
+ * Alias name for Slice.
+ */
+public typealias sl = Slice.Companion
+
+/**
+ * Stub start.
+ */
+public val sl.first: SliceStartStub
+    get() = SliceStartStub()
+
+/**
+ * Stub stop.
+ */
+public val sl.last: SliceEndStub
+    get() = SliceEndStub()
+
+/**
+ * Returns Slice with stubs the start and the stop.
+ */
+public val sl.bounds: Slice
+    get() = Slice(-1, -1, 1)
+
 /**
  * Slice class. An analogue of slices in python.
  */
-public class Slice(start: Int, stop: Int, step: Int) : Indexing {
+public class Slice(start: Int, stop: Int, step: Int) : Indexing, ClosedRange<Int> {
+
     init {
         if (step == 0 && start != 0 && stop != 0) throw IllegalArgumentException("Step must be non-zero.")
         if (step == Int.MIN_VALUE) throw kotlin.IllegalArgumentException("Step must be greater than Int.MIN_VALUE to avoid overflow on negation.")
     }
 
-    private var _start: Int = if (stop in 0 until start) stop else start
-    private var _stop: Int = if (_start == stop) start else stop
+    public companion object;
+
+    private var _start: Int = start
+    private var _stop: Int = stop
 
-    public val step: Int = if (step < 0) -step else step
-    public val start: Int get() = _start
+    public val step: Int = if (step < 0) throw IllegalArgumentException("Step must be positive.") else step
+    public override val start: Int get() = _start
     public val stop: Int get() = _stop
 
 
-    // TODO?
-    public fun indices(size: Int) {
+    override val endInclusive: Int
+        get() = stop
 
-    }
 
     public operator fun rangeTo(step: RInt): Slice = Slice(_start, _stop, step.data)
 
     public operator fun rangeTo(step: Int): Slice = Slice(_start, _stop, step)
 
-    //todo
-//    override fun contains(value: Int): Boolean = value in start..end
+    override fun contains(value: Int): Boolean = value in start..stop
 
-    //fun isEmpty(): Boolean = start == 0 && end == 0
+    override fun equals(other: Any?): Boolean =
+        other is Slice && (isEmpty() && other.isEmpty() ||
+                start == other.start && stop == other.stop && step == other.step)
 
-//    override fun equals(other: Any?): Boolean =
-//        other is IntRange && (isEmpty() && other.isEmpty() ||
-//                start == other.first && end == other.last)
-
-//    override fun hashCode(): Int =
-//        if (isEmpty()) -1 else (31 * start + end + step)
+    override fun hashCode(): Int =
+        if (isEmpty()) -1 else (31 * start + stop + step)
 
     override fun toString(): String = "$start..$stop..$step"
+}
 
-    public companion object {
-        /** An empty range of values of type Int. */
-        public val EMPTY: Slice = Slice(0, 0, 0)
+/**
+ * Returns Slice containing the first, the last with a step of 1.
+ */
+public fun IntRange.toSlice(): Slice = Slice(this.first, this.last, 1)
+
+/**
+ * Returns Slice containing the first, the last with a step of 1.
+ */
+public fun ClosedRange<Int>.toSlice(): Slice =
+    when(this) {
+        is Slice -> this
+        is IntRange -> this.toSlice()
+        else -> throw IllegalStateException("${this::class} not supported, please use Slice or IntRange.")
     }
-}
 
 /**
  * Returns [RInt].
@@ -75,14 +117,23 @@ public inline class RInt(internal val data: Int) : Indexing {
 }
 
 /**
- *
+ * Returns Slice with stub of the start.
+ */
+public operator fun SliceStartStub.rangeTo(that: Int): Slice = Slice(-1, that, 1)
+
+/**
+ * Returns Slice with stub of the stop.
+ */
+public operator fun Int.rangeTo(that: SliceEndStub): Slice = Slice(this, -1, 1)
+
+/**
+ * Returns Slice where stop from RInt.
  */
 public operator fun Int.rangeTo(that: RInt): Slice = Slice(this, that.data, 1)
 
-//TODO (Experimental)
 /**
  * Returns a slice at a specified [step].
  */
-public operator fun IntProgression.rangeTo(step: Int): Slice {
+public operator fun IntRange.rangeTo(step: Int): Slice {
     return Slice(this.first, this.last, step)
 }

multik-api/src/commonTest/kotlin/org/jetbrains/kotlinx/multik/ndarray/data/SliceTest.kt

@@ -0,0 +1,56 @@
+package org.jetbrains.kotlinx.multik.ndarray.data
+
+import org.jetbrains.kotlinx.multik.api.*
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class SliceTest {
+
+    @Test
+    fun testSlice1D() {
+        val a = mk.ndarrayOf(1, 2, 3, 4)
+
+
+        assertEquals(mk.ndarrayOf(2, 3), a[1..3])
+        assertTrue(a[3..1].isEmpty())
+        assertEquals(mk.ndarrayOf(1, 3), a[sl.bounds..2])
+    }
+
+    @Test
+    fun testSlice2D() {
+        val a = mk.d2array(3, 3) { it }
+
+        assertEquals(mk.ndarray(mk[mk[3, 4, 5], mk[6, 7, 8]]), a[1..3])
+        assertEquals(mk.ndarray(mk[mk[2], mk[5]]), a[0..2, 2..3])
+        assertEquals(mk.ndarrayOf(3), a[1, 0..1])
+        assertEquals(mk.ndarrayOf(5), a[1..2, 2])
+    }
+
+    @Test
+    fun testSlice3D() {
+        val a = mk.d3array(3, 3, 3) { it }
+
+        assertEquals(mk.d3array(2, 3, 3) { it + 9 }, a[1..3])
+        assertEquals(
+            mk.ndarray(mk[mk[mk[3, 4, 5], mk[6, 7, 8]], mk[mk[12, 13, 14], mk[15, 16, 17]]]),
+            a[0..2, 1..3, sl.bounds]
+        )
+        assertEquals(mk.ndarrayOf(15, 16), a[1, 2, 0..2])
+        assertEquals(mk.ndarrayOf(11, 14), a[1, 0..2, 2])
+        assertEquals(mk.ndarrayOf(5, 14), a[0..2, 1, 2])
+        assertEquals(mk.ndarray(mk[mk[4, 7], mk[13, 16]]), a[0..2, 1..3, 1])
+        assertEquals(mk.ndarray(mk[mk[4, 5], mk[13, 14]]), a[0..2, 1, 1..3])
+        assertEquals(mk.ndarray(mk[mk[10, 11], mk[13, 14]]), a[1, 0..2, 1..3])
+    }
+
+    @Test
+    fun testSlice4D() {
+        val a = mk.d4array(2, 2, 2, 2) { it }
+        assertEquals(a, a[sl.bounds])
+        assertEquals(mk.ndarray(mk[mk[mk[mk[5]]]]), a[0..1, 1..2, 0..1, 1..2])
+        assertEquals(mk.ndarray(mk[mk[mk[5]]]), a[0..1, 1, 0..1, 1..2..1])
+        assertEquals(mk.ndarray(mk[mk[7]]), a[0..1, 1, 1, 1..2])
+        assertEquals(mk.ndarrayOf(6), a[0..1, 1, 1, 0])
+    }
+}

multik-default/src/main/kotlin/org/jetbrains/kotlinx/multik/default/DefaultLinAlg.kt

@@ -21,17 +21,25 @@ public object DefaultLinAlg : LinAlg {
 
     override fun <T : Number> norm(mat: MultiArray<T, D2>, p: Int): Double = JvmLinAlg.norm(mat, p)
 
-    //TODO()
+    override fun <T : Number, D: Dim2> solve(a: MultiArray<T, D2>, b: MultiArray<T, D>): NDArray<T, D> {
+        return when (a.dtype) {
+            DataType.FloatDataType, DataType.DoubleDataType -> NativeLinAlg.dot(a, b)
+            else -> throw UnsupportedOperationException()
+        }
+    }
+
     override fun <T : Number, D : Dim2> dot(a: MultiArray<T, D2>, b: MultiArray<T, D>): NDArray<T, D> {
         return when (a.dtype) {
-            DataType.FloatDataType -> NativeLinAlg.dot(a, b)
-            DataType.DoubleDataType -> NativeLinAlg.dot(a, b)
+            DataType.FloatDataType, DataType.DoubleDataType -> NativeLinAlg.dot(a, b)
             else -> JvmLinAlg.dot(a, b)
         }
     }
 
     override fun <T : Number> dot(a: MultiArray<T, D1>, b: MultiArray<T, D1>): T {
-        return JvmLinAlg.dot(a, b)
+        return when(a.dtype) {
+            DataType.FloatDataType, DataType.DoubleDataType -> NativeLinAlg.dot(a, b)
+            else -> JvmLinAlg.dot(a, b)
+        }
     }
 
 }

multik-jvm/src/commonMain/kotlin/org/jetbrains/kotlinx/multik/jvm/JvmLinAlg.kt

@@ -30,6 +30,10 @@ public object JvmLinAlg : LinAlg {
         return n.pow(1 / p.toDouble())
     }
 
+    override fun <T : Number, D: Dim2> solve(a: MultiArray<T, D2>, b: MultiArray<T, D>): NDArray<T, D> {
+        TODO("Not yet implemented")
+    }
+
     override fun <T : Number, D : Dim2> dot(a: MultiArray<T, D2>, b: MultiArray<T, D>): NDArray<T, D> {
         require(a.shape[1] == b.shape[0]) { "Shapes mismatch: shapes " +
                 "${a.shape.joinToString(prefix = "(", postfix = ")")} and " +

multik-jvm/src/commonTest/kotlin/org/jetbrains/kotlinx/multik_jvm/math/JvmMathTest.kt

@@ -23,6 +23,15 @@ class JvmMathTest {
         initEnginesProvider(listOf(JvmEngine()))
     }
 
+    @Test
+    fun `test of argMax function Double`() {
+        val ndarray1 = mk.ndarray(mk[0.008830892, 0.7638366187, -0.0401326368965, -0.269757419187])
+        val ndarray2 = mk.ndarray(mk[0.0088308926050, 0.763836618743, Double.NaN, -0.2697574191872])
+
+        assertEquals(1, mk.math.argMax(ndarray1))
+        assertEquals(2, mk.math.argMax(ndarray2))
+    }
+
     @Test
     fun `test of argMax function with axis`() {
         val ndarray = mk.ndarray(mk[mk[mk[50, 3], mk[1, 4]], mk[mk[2, 5], mk[6, 8]], mk[mk[7, 9], mk[10, 11]]])

multik-native/src/main/kotlin/org/jetbrains/kotlinx/multik/jni/JniLinAlg.kt

@@ -17,6 +17,30 @@ public object NativeLinAlg : LinAlg {
         TODO("Not yet implemented")
     }
 
+    override fun <T : Number, D : Dim2> solve(a: MultiArray<T, D2>, b: MultiArray<T, D>): NDArray<T, D> {
+        require(a.shape[0] == a.shape[1]) { "Ndarray must be square: a.shape = ${a.shape.joinToString(",", "(", ")")}" }
+        require(a.shape[0] == b.shape[0]) { "The first dimensions of the ndarrays a and b must be match: ${a.shape[0]}(a.shape[0]) != ${b.shape[0]}(b.shape[0]" }
+        val ret = if (b.consistent) (b as NDArray).clone() else (b as NDArray).deepCopy()
+        val nhrs = if (ret.dim.d == 1) ret.shape[0] else ret.shape[1]
+
+        val info: Int = when (a.dtype) {
+            DataType.FloatDataType -> JniLinAlg.solve(
+                a.shape.first(), nhrs, a.data.getFloatArray().copyOf(), a.strides.first(),
+                ret.data.getFloatArray(), ret.strides.first()
+            )
+            DataType.DoubleDataType -> JniLinAlg.solve(
+                a.shape.first(), nhrs, a.data.getDoubleArray().copyOf(), a.strides.first(),
+                ret.data.getDoubleArray(), ret.strides.first()
+            )
+            else -> throw UnsupportedOperationException()
+        }
+        if (info > 0) {
+            throw Exception("The diagonal element of the triangular factor of a is zero, so that A is singular. The solution could not be computed.")
+        }
+
+        return ret
+    }
+
     //TODO (Double and Number type)
     override fun <T : Number, D : Dim2> dot(a: MultiArray<T, D2>, b: MultiArray<T, D>): NDArray<T, D> {
         require(a.shape[1] == b.shape[0]) {
@@ -60,17 +84,42 @@ public object NativeLinAlg : LinAlg {
     }
 
     override fun <T : Number> dot(a: MultiArray<T, D1>, b: MultiArray<T, D1>): T {
-        TODO("Not yet implemented")
+        require(a.size == b.size) { "Vector sizes don't match: ${a.size} != ${b.size}" }
+        return when (a.dtype) {
+            DataType.FloatDataType -> {
+                JniLinAlg.dot(
+                    a.size,
+                    a.data.getFloatArray(),
+                    a.strides.first(),
+                    b.data.getFloatArray(),
+                    b.strides.first()
+                )
+            }
+            DataType.DoubleDataType -> {
+                JniLinAlg.dot(
+                    a.size,
+                    a.data.getDoubleArray(),
+                    a.strides.first(),
+                    b.data.getDoubleArray(),
+                    b.strides.first()
+                )
+            }
+            else -> throw UnsupportedOperationException()
+        } as T
     }
 }
 
 private object JniLinAlg {
-    external fun <T : Number> pow(mat: FloatArray, n: Int, result: FloatArray): Unit
-    external fun <T : Number> pow(mat: DoubleArray, n: Int, result: DoubleArray): Unit
-    external fun <T : Number> norm(mat: FloatArray, p: Int): Double
-    external fun <T : Number> norm(mat: DoubleArray, p: Int): Double
+    external fun pow(mat: FloatArray, n: Int, result: FloatArray): Unit
+    external fun pow(mat: DoubleArray, n: Int, result: DoubleArray): Unit
+    external fun norm(mat: FloatArray, p: Int): Double
+    external fun norm(mat: DoubleArray, p: Int): Double
+    external fun solve(n: Int, nrhs: Int, a: FloatArray, strA: Int, b: FloatArray, strB: Int): Int
+    external fun solve(n: Int, nrhs: Int, a: DoubleArray, strA: Int, b: DoubleArray, strB: Int): Int
     external fun dot(a: FloatArray, m: Int, n: Int, b: FloatArray, k: Int, c: FloatArray): Unit
     external fun dot(a: DoubleArray, m: Int, n: Int, b: DoubleArray, k: Int, c: DoubleArray): Unit
     external fun dot(a: FloatArray, m: Int, n: Int, b: FloatArray, c: FloatArray): Unit
     external fun dot(a: DoubleArray, m: Int, n: Int, b: DoubleArray, c: DoubleArray): Unit
+    external fun dot(n: Int, a: FloatArray, strideA: Int, b: FloatArray, strideB: Int): Float
+    external fun dot(n: Int, a: DoubleArray, strideA: Int, b: DoubleArray, strideB: Int): Double
 }