[fix:] fix test on windows

Author: devcrocod

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

@@ -0,0 +1,13 @@
+package org.jetbrains.kotlinx.multik.jni
+
+import org.jetbrains.kotlinx.multik.ndarray.data.Dimension
+import org.jetbrains.kotlinx.multik.ndarray.data.NDArray
+import org.jetbrains.kotlinx.multik.ndarray.operations.map
+import java.math.BigDecimal
+import java.math.RoundingMode
+
+fun <D: Dimension> roundDouble(ndarray: NDArray<Double, D>): NDArray<Double, D> =
+    ndarray.map { BigDecimal(it).setScale(2, RoundingMode.HALF_UP).toDouble() }
+
+fun <D: Dimension> roundFloat(ndarray: NDArray<Float, D>): NDArray<Float, D> =
+    ndarray.map { BigDecimal(it.toDouble()).setScale(2, RoundingMode.HALF_UP).toFloat() }

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

@@ -4,6 +4,8 @@ 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 org.jetbrains.kotlinx.multik.jni.roundDouble
+import org.jetbrains.kotlinx.multik.jni.roundFloat
 import kotlin.test.BeforeTest
 import kotlin.test.Test
 import kotlin.test.assertEquals
@@ -18,10 +20,10 @@ class NativeLinAlgTest {
     @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]]
+            mk[mk[1.07, 0.62, 0.46, 0.48],
+                    mk[0.82, 0.72, 0.79, 0.82],
+                    mk[0.53, 0.48, 0.53, 0.51],
+                    mk[1.04, 0.76, 0.71, 0.66]]
         )
         val matrix1 = mk.ndarray(
             mk[mk[0.22, 0.9, 0.27],
@@ -36,16 +38,16 @@ class NativeLinAlgTest {
         )
 
         val actual = NativeLinAlg.dot(matrix1, matrix2)
-        assertEquals(expected, actual)
+        assertEquals(expected, roundDouble(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]]
+            mk[mk[1.07f, 0.62f, 0.46f, 0.48f],
+                    mk[0.82f, 0.72f, 0.79f, 0.82f],
+                    mk[0.53f, 0.48f, 0.53f, 0.51f],
+                    mk[1.04f, 0.76f, 0.71f, 0.66f]]
         )
         val matrix1 = mk.ndarray(
             mk[mk[0.22f, 0.9f, 0.27f],
@@ -60,12 +62,12 @@ class NativeLinAlgTest {
         )
 
         val actual = NativeLinAlg.dot(matrix1, matrix2)
-        assertEquals(expected, actual)
+        assertEquals(expected, roundFloat(actual))
     }
 
     @Test
     fun `matrix-vector dot test D`() {
-        val expected = mk.ndarray(mk[0.8006, 0.663, 0.5771])
+        val expected = mk.ndarray(mk[0.80, 0.66, 0.58])
 
         val matrix = mk.ndarray(
             mk[mk[0.22, 0.9, 0.27],
@@ -75,12 +77,12 @@ class NativeLinAlgTest {
         val vector = mk.ndarray(mk[0.08, 0.63, 0.8])
 
         val actual = NativeLinAlg.dot(matrix, vector)
-        assertEquals(expected, actual)
+        assertEquals(expected, roundDouble(actual))
     }
 
     @Test
     fun `matrix-vector dot test F`() {
-        val expected = mk.ndarray(mk[0.8006f, 0.663f, 0.5771f])
+        val expected = mk.ndarray(mk[0.80f, 0.66f, 0.58f])
 
         val matrix = mk.ndarray(
             mk[mk[0.22f, 0.9f, 0.27f],
@@ -90,6 +92,6 @@ class NativeLinAlgTest {
         val vector = mk.ndarray(mk[0.08f, 0.63f, 0.8f])
 
         val actual = NativeLinAlg.dot(matrix, vector)
-        assertEquals(expected, actual)
+        assertEquals(expected, roundFloat(actual))
     }
 }

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

@@ -4,8 +4,11 @@ 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.jni.roundDouble
 import org.jetbrains.kotlinx.multik.ndarray.data.D2
 import org.jetbrains.kotlinx.multik.ndarray.data.NDArray
+import java.math.BigDecimal
+import java.math.RoundingMode
 import kotlin.test.BeforeTest
 import kotlin.test.Test
 import kotlin.test.assertEquals
@@ -31,26 +34,26 @@ class NativeMathTest {
 
     @Test
     fun expTest() {
-        val expected = mk.ndarray(mk[mk[298.8673439626328, 2.9446796774374633], mk[9136.200570869447, 34.813315827573724]])
-        assertEquals(expected, NativeMath.exp(ndarray))
+        val expected = mk.ndarray(mk[mk[298.87, 2.94], mk[9136.2, 34.81]])
+        assertEquals(expected, roundDouble(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))
+        val expected = mk.ndarray(mk[mk[1.74, 0.08], mk[2.21, 1.27]])
+        assertEquals(expected, roundDouble(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))
+        val expected = mk.ndarray(mk[mk[-0.55, 0.88], mk[0.3, -0.4]])
+        assertEquals(expected, roundDouble(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))
+        val expected = mk.ndarray(mk[mk[0.83, 0.47], mk[-0.95, -0.92]])
+        assertEquals(expected, roundDouble(NativeMath.cos(ndarray)))
     }
 
     @Test