Hey all, sorry I've gone dark for awhile. I've been juggling a lot of stuff, all good. I might have a Kotlin differential programming project headed my way with a client. If it goes through I'll be plugging back in shortly.

1.Could someone help me figure out the differences between KMath and MultiK ? 2.When should we use one over the other ?Should we use both ? What if we're interested in tensors manipulation ? 3. Are they both still being developed?

I plan to repeat my talk about Math architecture (and difference between KMath approach and Multik as well) from Joker in English. Is January 28 15:00 CET OK for everyone interested?

Why can't I see it the other way around as the relationship is from co domain to domain and use the same above understanding and say Oh I see a function ? Basically relationship identified across sers be it domian -> co domain Or co domain -> domain Then I can map it with directions as in Graph Theory style with a function definition above the directed relationship identified ?

Does anyone know why Kotlin BigDecimal div operator decided to use the scaling of the nominator and behave different from the equivalent Java implementation?

import java.math.BigDecimal

val x = BigDecimal("127.0")
val y = BigDecimal("50")

println(x / y)  // 2.5 unexpected
println(x.divide(y)) // 2.54 what I expected

Took me while to figure out why what was going on in my code and I cannot see many cases where this is the desired behaviour. Would rather have the div operator just calling the divide method.

This message was deleted.

Latest matrix dot (1000 x 1000 matrices) benchmark results for different KMath algebras (after tensor algebra fix by @Ivan Kylchik:

jvm summary:
Benchmark                            Mode  Cnt   Score   Error  Units
DotBenchmark.bufferedDot            thrpt    5   1.017 ± 0.399  ops/s
DotBenchmark.cmDot                  thrpt    5   0.589 ± 0.348  ops/s
DotBenchmark.cmDotWithConversion    thrpt    5   0.627 ± 0.395  ops/s
DotBenchmark.doubleDot              thrpt    5   1.168 ± 0.125  ops/s
DotBenchmark.doubleTensorDot        thrpt    5   1.263 ± 0.235  ops/s
DotBenchmark.ejmlDot                thrpt    5   2.573 ± 0.427  ops/s
DotBenchmark.ejmlDotWithConversion  thrpt    5   2.332 ± 0.239  ops/s
DotBenchmark.multikDot              thrpt    5  16.067 ± 0.959  ops/s
DotBenchmark.tensorDot              thrpt    5   0.614 ± 0.053  ops/s
DotBenchmark.tfDot                  thrpt    5   3.905 ± 0.541  ops/s

Multik result (cc @Pavel Gorgulov) is a bit surprising. I did not expect it to be much faster than TensorFlow. KMath-core results are good enough for default implementation.

Is it possible to use KMaths for deep learning inference on Native (I think KMaths is multiplatform right?)? (Eg: via ONNX model)

Hello just wondering, does KMath have a function to compute the area of the intersection between two rectangles ?

fun Int.floorEven() = this and 0x01.inv()

I was reading a project and i saw this code but i could not understand why this code flooring the number to even i know 01 inverse equals to -2 because of 2's complement equals to 1's complement - 1 and 2 complent is negative of that number but i could not understand why this code will always work?

Does anyone know if multik has something like np.roll() for d2Array?

Does anyone have a handy link for 3d <> 1d array index conversions? Google only surfaces the common 2d<>1d... I basically need to get x,y,z coordinates from a given 1d array index

Anyone here familiar with OpenCV Java and would be willing to answer a few questions about Dnn and Mat? The docs for java are pretty much non-existent and the API differs quite a lot in some places from Python...

Does anybody want earth coordinate transformation? I've added them because people asked me but I wonder if there are specific features people need? For example distance computations?

@ESchouten By the way, a team in our centre is currently working on enhancement of Dubins algorithm. They are doing it in Python, but probably it would be interesting to have it in Kotlin. Would you be interesting to include your implementation in KMath-geometry, or it is better to have it in a separate package?

Ideomatic way to get the closest multiple of .5 to a given float? E.g.

closest(1.03)=1.05

,

closest(1.02)=1.00

,

closest(1.05)=1.05

How do you get the fractional part of a double?

@Gleb Minaev I've started to do a review on your PR. It is too large to be in

functions

module (it is intended to be lightweight). Could you create a separate module like

kmath-rational

and move all but basic polynomials there?

Meta just open-sourced an automatic differentiation framework for Kotlin! (https://diffkt.org/). It can compute higher-order and symbolic derivatives, supports user-defined types, and has compile-time shape checking. Examples include machine learning and physical simulations.

This message was deleted.

Inspired by Facebook, I finally finished refactoring of @Iaroslav Postovalov’s PR on generic autodiff in KMath. It is merged into

dev

and yes, it can work with tensors and allows custom operators: https://github.com/mipt-npm/kmath/blob/dev/kmath-core/src/commonTest/kotlin/space/kscience/kmath/expressions/DerivativeStructureExpressionTest.kt. Documentation is not ready yet, but any feedback would be welcome. The difference from Facebook implementation is that operations themselves (including performance optimization) are decoupled from the autodiff algorithm. So you can for example use Multik native implementation with the autodif engine.

To add to the automatic differentiation implementations, https://github.com/facebookresearch/optimizer-plugins is also now open source

@ESchouten thanks for the contribution. It is finally merged. I want to do some post-merge changes. Mostly related to computation of the "costs" of path. We have cases, where it is not "path length", but some value that depends on the specific point. So it will be some kind of visitor. Also I will probably change structure somewhat to better conform to the other code. Meanwhile, you can check the complementary project: https://github.com/mipt-npm/maps-kt. It allows (or will allow) to visualize the path on maps and schemes.

message has been deleted

@Pavel Gorgulov I finished migrating KMath multik integration to MPP: https://github.com/mipt-npm/kmath/commit/a8182fad23417f4302ea77ccdeba3b931e50a471. The only major problem is that service provider mechanism does not work on JS (see https://youtrack.jetbrains.com/issue/KT-53056/Multiplatform-equivalent-of-JVMs-ServiceLoader). So getters like

Multik.stat

fail by default there. Engines must be loaded manually and it should be mentioned in the documentation.

I am thinking about replacing all @Ролан postfix notations in tensors like

tensor.lup()

with prefix notations like

Algebra::lup(tensor)

. It allows much more robust use of contexts and extensions and in my opinion is much more readable. In numpy/Torch postfix notation is used mostly because it could not be done in the other way. The only thing we loose is easy chaining (it could be brought back via scope functions). Does anybody know a case with real complicated chaining on tensors?

I'm experimenting with writing a DSL for AST matching (and hopefully also property extraction). I'm curious if anyone knows of prior art.