{"id":115614,"date":"2021-02-17T14:10:46","date_gmt":"2021-02-17T13:10:46","guid":{"rendered":"https:\/\/blog.jetbrains.com\/?post_type=kotlin&p=115614"},"modified":"2021-04-28T22:15:23","modified_gmt":"2021-04-28T21:15:23","slug":"multik-multidimensional-arrays-in-kotlin","status":"publish","type":"kotlin","link":"https:\/\/blog.jetbrains.com\/fr\/kotlin\/2021\/02\/multik-multidimensional-arrays-in-kotlin","title":{"rendered":"Multik: Multidimensional Arrays in Kotlin"},"content":{"rendered":"

A lot of data-heavy tasks, as well as optimization problems, boil down to performing computations over multidimensional arrays. Today we\u2019d like to share with you the first preview of a library that aims to serve as a foundation for such computations \u2013 Multik<\/a>. <\/p>\n

Multik offers both multidimensional array data structures and implementations of mathematical operations over them. The library has a simple and straightforward API and offers optimized performance. <\/p>\n

Using Multik<\/h2>\n

Without further ado, here are some of the things you can do with Multik. <\/p>\n

Create multidimensional arrays<\/h3>\n

Create a vector:<\/p>\n

\r\nval a = mk.ndarray(mk[1, 2, 3])\r\n\/* [1, 2, 3] *\/\r\n<\/pre>\n<\/p>\n
Create a vector from a collection:<\/p>\n
\r\nval myList = listOf(1, 2, 3)\r\nval a = mk.ndarray(myList)\r\n\/* [1, 2, 3] *\/\r\n<\/pre>\n<\/p>\n
Create a matrix (two-dimensional array):<\/p>\n
\r\nval m = mk.ndarray(mk[myList, myList])\r\n\/*\r\n[[1, 2, 3],\r\n[1, 2, 3]]\r\n*\/\r\n<\/pre>\n<\/p>\n
Create a fixed-shape array of zeros:<\/p>\n
\r\nmk.empty<Double, D2>(3, 4)\r\n\/*\r\n[[0.0, 0.0, 0.0, 0.0],\r\n[0.0, 0.0, 0.0, 0.0],\r\n[0.0, 0.0, 0.0, 0.0]]\r\n*\/\r\n<\/pre>\n<\/p>\n
Create an identity matrix (ones on the diagonal, the rest is set to 0)<\/p>\n
\r\nval e = mk.identity<Double>(3) \/\/ create an identity array of shape (3, 3)\r\n\/*\r\n[[1.0, 0.0, 0.0],\r\n[0.0, 1.0, 0.0],\r\n[0.0, 0.0, 1.0]]\r\n*\/\r\n<\/pre>\n<\/p>\n
Create a 3-dimensional array (multik supports up to 4 dimensions):<\/p>\n
\r\nmk.d3array(2, 2, 3) { it * it } \r\n\/*\r\n[[[0, 1, 4],\r\n[9, 16, 25]],\r\n\r\n[[36, 49, 64],\r\n[81, 100, 121]]]\r\n*\/\r\n<\/pre>\n<\/p>\n
Perform mathematical operations over multidimensional arrays<\/h3>\n
\r\nval a = mk.ndarray(mk[mk[1.0,2.0], mk[3.0,4.0]])\r\nval b = mk.identity<Double>(2)\r\n\r\na + b\r\n\/*\r\n[[2.0, 2.0],\r\n[3.0, 5.0]]\r\n*\/\r\n<\/pre>\n
\r\na - b\r\n\/*\r\n[[0.0, 2.0],\r\n[3.0, 3.0]]\r\n*\/\r\n<\/pre>\n
\r\nb \/ a\r\n\/*\r\n[[1.0, 0.0],\r\n[0.0, 0.25]]\r\n*\/\r\n<\/pre>\n
\r\nb * a \r\n\/*\r\n[[1.0, 0.0],\r\n[0.0, 4.0]]\r\n*\/\r\n<\/pre>\n
Element-wise mathematical operations<\/h3>\n
\r\nmk.math.sin(a) \/\/ element-wise sin \r\nmk.math.cos(a) \/\/ element-wise cos\r\nmk.math.log(b) \/\/ element-wise natural logarithm\r\nmk.math.exp(b) \/\/ element-wise exp\r\nmk.linalg.dot(a, b) \/\/ dot product\r\n<\/pre>\n
Aggregate functions<\/h3>\n
\r\nmk.math.sum(a) \/\/ array-wise sum\r\nmk.math.min(b) \/\/ array-wise minimum elements\r\nmk.math.cumSum(b, axis=1) \/\/ cumulative sum of the elements\r\nmk.stat.mean(a) \/\/ mean\r\nmk.stat.median(b) \/\/ median\r\n<\/pre>\n
Iterable operations<\/h3>\n
\r\na.filter { it > 3 } \/\/ select all elements that are larger than 3\r\nb.map { (it * it).toInt() } \/\/ return squares\r\na.groupNdarrayBy { it % 2 } \/\/ group elements by condition\r\na.sorted() \/\/ sort elements\r\n<\/pre>\n
Indexing\/Slicing\/Iterating<\/h3>\n
\r\na[2]  \/\/ select the element at the 2 index for a vector\r\nb[1, 2] \/\/ select the element at row 1 column 2\r\nb[1] \/\/ select row 1 \r\nb[0.r..2, 1] \/\/ select elements at rows 0 and 1 in column 1\r\nb[0..1..1] \/\/ select all elements at row 0\r\n<\/pre>\n
\r\nfor (el in b) {\r\n    print("$el, ") \/\/ 1.5, 2.1, 3.0, 4.0, 5.0, 6.0, \r\n}\r\n<\/pre>\n
\r\n\/\/ for n-dimensional\r\nval q = b.asDNArray()\r\nfor (index in q.multiIndices) {\r\n    print("${q[index]}, ") \/\/ 1.5, 2.1, 3.0, 4.0, 5.0, 6.0, \r\n}\r\n<\/pre>\n
Multik Architecture<\/h2>\n
Initially, we attempted to add Kotlin bindings to existing solutions, such as NumPy. However, this proved cumbersome and introduced unnecessary environmental complexity while providing little benefit to justify the overhead. As a result, we have abandoned that approach and started Multik from scratch.<\/p>\n
In Multik, the data structures are separate from the implementation of operations over them, and you need to add them as individual dependencies to your project. This approach gives you a consistent API no matter what implementation you decide to use in your project. So what are these different implementations?<\/p>\n
Currently, there are three different ones: <\/p>\n