[test:] add jni test

Author: devcrocod

multik-native/src/test/kotlin/org/jetbrains/kotlinx/multik/jni/linalg/NativeLinAlgTest.kt

@@ -0,0 +1,95 @@
+package org.jetbrains.kotlinx.multik.jni.linalg
+
+import org.jetbrains.kotlinx.multik.api.mk
+import org.jetbrains.kotlinx.multik.api.ndarray
+import org.jetbrains.kotlinx.multik.jni.Loader
+import org.jetbrains.kotlinx.multik.jni.NativeLinAlg
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class NativeLinAlgTest {
+
+    @BeforeTest
+    fun load() {
+        Loader("multik_jni").manualLoad()
+    }
+
+    @Test
+    fun `matrix-matrix dot test D`() {
+        val expected = mk.ndarray(
+            mk[mk[1.0718999999999999, 0.6181, 0.46080000000000004, 0.48109999999999997],
+                    mk[0.8210999999999999, 0.7162, 0.79, 0.8199],
+                    mk[0.5287999999999999, 0.48339999999999994, 0.5342, 0.5082],
+                    mk[1.0353, 0.758, 0.7114, 0.6647]]
+        )
+        val matrix1 = mk.ndarray(
+            mk[mk[0.22, 0.9, 0.27],
+                    mk[0.97, 0.18, 0.59],
+                    mk[0.29, 0.13, 0.59],
+                    mk[0.08, 0.63, 0.8]]
+        )
+        val matrix2 = mk.ndarray(
+            mk[mk[0.36, 0.31, 0.36, 0.44],
+                    mk[0.95, 0.44, 0.22, 0.25],
+                    mk[0.51, 0.57, 0.68, 0.59]]
+        )
+
+        val actual = NativeLinAlg.dot(matrix1, matrix2)
+        assertEquals(expected, actual)
+    }
+
+    @Test
+    fun `matrix-matrix dot test F`() {
+        val expected = mk.ndarray(
+            mk[mk[1.0719f, 0.6181f, 0.4608f, 0.4811f],
+                    mk[0.8211f, 0.7162f, 0.79f, 0.8199f],
+                    mk[0.52879995f, 0.48339996f, 0.5342f, 0.5082f],
+                    mk[1.0353f, 0.758f, 0.71140003f, 0.6647f]]
+        )
+        val matrix1 = mk.ndarray(
+            mk[mk[0.22f, 0.9f, 0.27f],
+                    mk[0.97f, 0.18f, 0.59f],
+                    mk[0.29f, 0.13f, 0.59f],
+                    mk[0.08f, 0.63f, 0.8f]]
+        )
+        val matrix2 = mk.ndarray(
+            mk[mk[0.36f, 0.31f, 0.36f, 0.44f],
+                    mk[0.95f, 0.44f, 0.22f, 0.25f],
+                    mk[0.51f, 0.57f, 0.68f, 0.59f]]
+        )
+
+        val actual = NativeLinAlg.dot(matrix1, matrix2)
+        assertEquals(expected, actual)
+    }
+
+    @Test
+    fun `matrix-vector dot test D`() {
+        val expected = mk.ndarray(mk[0.8006, 0.663, 0.5771])
+
+        val matrix = mk.ndarray(
+            mk[mk[0.22, 0.9, 0.27],
+                    mk[0.97, 0.18, 0.59],
+                    mk[0.29, 0.13, 0.59]]
+        )
+        val vector = mk.ndarray(mk[0.08, 0.63, 0.8])
+
+        val actual = NativeLinAlg.dot(matrix, vector)
+        assertEquals(expected, actual)
+    }
+
+    @Test
+    fun `matrix-vector dot test F`() {
+        val expected = mk.ndarray(mk[0.8006f, 0.663f, 0.5771f])
+
+        val matrix = mk.ndarray(
+            mk[mk[0.22f, 0.9f, 0.27f],
+                    mk[0.97f, 0.18f, 0.59f],
+                    mk[0.29f, 0.13f, 0.59f]]
+        )
+        val vector = mk.ndarray(mk[0.08f, 0.63f, 0.8f])
+
+        val actual = NativeLinAlg.dot(matrix, vector)
+        assertEquals(expected, actual)
+    }
+}

multik-native/src/test/kotlin/org/jetbrains/kotlinx/multik/jni/math/NativeMathTest.kt

@@ -0,0 +1,70 @@
+package org.jetbrains.kotlinx.multik.jni.math
+
+import org.jetbrains.kotlinx.multik.api.mk
+import org.jetbrains.kotlinx.multik.api.ndarray
+import org.jetbrains.kotlinx.multik.jni.Loader
+import org.jetbrains.kotlinx.multik.jni.NativeMath
+import org.jetbrains.kotlinx.multik.ndarray.data.D2
+import org.jetbrains.kotlinx.multik.ndarray.data.NDArray
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class NativeMathTest {
+
+    val ndarray: NDArray<Float, D2> = mk.ndarray(mk[mk[5.7f, 1.08f], mk[9.12f, 3.55f]])
+
+    @BeforeTest
+    fun load() {
+        Loader("multik_jni").manualLoad()
+    }
+
+    @Test
+    fun argMaxTest() {
+        assertEquals(2, NativeMath.argMax(ndarray))
+    }
+
+    @Test
+    fun argMinTest() {
+        assertEquals(1, NativeMath.argMin(ndarray))
+    }
+
+    @Test
+    fun expTest() {
+        val expected = mk.ndarray(mk[mk[298.8673439626328, 2.9446796774374633], mk[9136.200570869447, 34.813315827573724]])
+        assertEquals(expected, NativeMath.exp(ndarray))
+    }
+
+    @Test
+    fun logTest() {
+        val expected = mk.ndarray(mk[mk[1.7404661413782472, 0.07696108087255739], mk[2.2104697915378937, 1.2669475900552918]])
+        assertEquals(expected, NativeMath.log(ndarray))
+    }
+
+    @Test
+    fun sinTest() {
+        val expected = mk.ndarray(mk[mk[-0.5506857018064566, 0.8819578271121656], mk[0.300081485531831, -0.39714812352401446]])
+        assertEquals(expected, NativeMath.sin(ndarray))
+    }
+
+    @Test
+    fun cosTest() {
+        val expected = mk.ndarray(mk[mk[0.8347126798042128, 0.47132832632421673], mk[-0.9539135715781643, -0.9177545249037752]])
+        assertEquals(expected, NativeMath.cos(ndarray))
+    }
+
+    @Test
+    fun maxTest() {
+        assertEquals(9.12f, NativeMath.max(ndarray))
+    }
+
+    @Test
+    fun minTest() {
+        assertEquals(1.08f, NativeMath.min(ndarray))
+    }
+
+    @Test
+    fun sumTest() {
+        assertEquals(19.449999f, NativeMath.sum(ndarray))
+    }
+}