kmath getting started and how to use examples. With kmath there seems to be very little documentation for getting started and transitioning from numpy to kmath. Is there any guide for this such as how to do a linspace function?

Hello, @breandan . We are experiencing problems with stable access to Princess library. Is it mandatory to use KotlinGrad

SFun

related interfaces? I suppose this library can either be published to more stable Maven repository or removed from KotlinGrad core module, then extracted to a separate module that does use Princess.

@alex cole By the way, I just rememebered that I had an article about migration from Python notebook to Kotlin notebook: https://levelup.gitconnected.com/a-first-dive-into-kotlin-jupyter-eab43dca9472. The visualization and tooling became much better since then.

Just sent a PR to KMath that replaces syntax of dynamic calls of algebraic operations from

algebra.binaryOperation("+", 1, 1)

to

algebra.binaryOperation("+")(1, 1)

. This feature also affects ASM code generation so generated classes store functional objects returned by

*aryOperation("...")

methods instead of storing algebraic structures.

Hi @altavir all the other issues are resolved while integrating the Plotly library. I had another question related to it I have tried to articulate it over here. https://stackoverflow.com/questions/65246043/how-to-plot-a-coordinate-graph-using-plotly-kt-for-y-1-x Please let me know once you are free.

I have been working on putting together a basic numerical methods library and was wondering what I could do to build an api primarily for this linear regression class. Also what is the best way to assert equals when the known values differ in significant figures from the actualValue. https://github.com/jalexcole/NumericalMethods/blob/master/src/main/kotlin/curveFitting/regression/LinearRegression.kt

Did some experiments with type classes. It's a nice pattern for abstract algebra: https://github.com/breandan/kotlingrad/blob/master/core/src/main/kotlin/edu/umontreal/kotlingrad/typelevel/TypeClassing.kt

Is there a preferred jdk, garbage collector, etc. that is best used for numerical loads?

message has been deleted

I'm pretty dumb when it comes to software licenses. What are the implications of porting and heavily modifying something like BigInteger from the openJdk source to kotlin? Is that allowed? Do I just need to keep the license part, and does that apply to my entire project or just that class?

By the way, here are the results of naive tests (no JMH, so be careful with conclusions) on GraalVM11:

Boxing addition completed in 22157 millis

Specialized addition completed in 1840 millis

Nd4j specialized addition completed in 1309 millis

Viktor addition completed in 1966 millis

Parallel stream addition completed in 1457 millis

Automatic field addition completed in 1773 millis

Lazy addition completed in 14157 millis

ND4J uses OpenBlas under the hood. And I think @Iaroslav Postovalov told me that is uses parallel execution. I wonder if there is a large overhead on top of BLAS. Because the results are very close.

Interesting, it seems the term "field" used in algebra and physics are related. To check if a set of matrices is an algebraic field, it must be closed under (+, -, *), have additive identity, multiplicative identity and commutativity, and a multiplicative inverse. The term vector/matrix field used differential geometry and physics is a actually a vector/matrix space over a field, i.e. the product of a field and a vector/matrix space, whose elements are vectors/matrices. The type signatures are slightly different. Algebraic field: ×: 𝔽 × 𝔽 → 𝔽 +: 𝔽 × 𝔽 → 𝔽 Vector field: +: 𝔽ⁿ × 𝔽ⁿ → 𝔽ⁿ ⋅: 𝔽 × 𝔽ⁿ → 𝔽ⁿ cc: @altavir @dievsky

Is the@Aleksei Dievskii the correct tag-name for Alexei, I think.

Happy to see experimental support for sealed interfaces arriving in 1.5. Together with multiple inheritance and default methods, this opens up a path to implementing algebraic data types: https://blog.jetbrains.com/kotlin/2021/02/new-language-features-preview-in-kotlin-1-4-30/#sealed-interfaces AFAICT, this feature offers the same benefits of multiple receivers without needing to introduce a new syntax. Or is there some feature that KEEP-176 proposes which could not be implemented using the type class pattern on a sealed interface?

Somebody ever tried to solve the problem of the classes schedule optimization? I not it is not simple, but I know it could be solved. I asked different students to do the algorithm for that for years, but nobody managed to do that. And it requires more knowledge of descreete optimization, than I have.

message has been deleted

Following the week of mathematical releases in Kotlin, I am happy to present KMath release 0.2.0: https://github.com/mipt-npm/kmath/releases/tag/v0.2.0. The release contains numerous new features and API fixes as well as new pacckage name (

space.kscience

) and a completely new understanding of library aims. KMath does not want to follow numpy path and provide bindings for a single implementation of nd-arrays and numerics. Instead, we are working on a Kotlin-first API, that allows us to better tap into the kotlin lagnuage potential and allow to create the same or similar API to different existing libraries, so one could easily switch implementations withot a lot of changes in the code. Also we provide simple multiplatform implementations for people, who do not need super-optimized performance. Those basic implementations are thereby referenced as kmath-core to avoid confusion with library bindings like kmath-commons, kmath-ejml, kmath-viktor etc. The important feature of the new release is the new documenation and stability policy. Ecch module has a Maturity level shown in the documentation: • PROTOTYPE - both idea an the implementation may change. • EXPERIMENTAL - we have an idea how it should look like, but implementation could change in minor versions. • DEVELOPMENT - API compatibility between monitor versions is controlled via https://github.com/Kotlin/binary-compatibility-validator. • STABLE - no module has reached this stage yet, but we plan to enforce production-ready stability guarantees. New documentation plugin allows to maintain the list of module features. Here is the list of key feature modules: • kmath-core Core classes, algebra definitions, basic linear algebra, nd-structures, expressions etc. • kmath-commons Bindings for Commons-math library. • kmath-complex Complex numbers and quternions (separated from core in this release. • kmath-nd4j ND4J bindings for nd-structures implementation. • kmath-ejml EJML bindings for linear algebra implementatiion. • kmath-viktor JetBrains Research Viktor bindings for real-valued nd-structures. • kmath-histograms Univariate and multivariate histograms. • kmath-ast MST (mathematical syntax tree) definition, JIT expression compilation with ASM on JVM and JS interpreter on JS. Symbolic algebra. • kmath-kotlingrad Automatic differentiation via MST and kotlingrad library. The significant part of the release is done by @Iaroslav Postovalov. I would also like to thank a lot of people, including @breandan, @Peter Klimai, @elizarov , @Ролан, @Aleksei Dievskii, @roman.belov, @Pavel Gorgulov and numerous others (I can't remember them all, we need a list), for discussions and contributions. The project is supported by the JetBrains Research.

@Aleksei Dievskii A question about algebras. Could you give an example of a

Space

which does not have a numeric scaling of its members? We have some problems bringing KMath inheritance model in check and keep it practical so I am thinkgin about different architectural approaches.

This Friday Mar. 26th at 12:00 EDT / 16:00 UTC we are hosting Erik Meijer at our reading group. He will discuss some mathematical topics, possibly related to Kotlin somehow. In case anyone here is available, please feel welcome to drop by and say hello! It would be great to have your feedback.

Inside Every Calculus Is A Little Algebra Waiting To Get Out

Because of deep learning, there has been a surge in interest in automatic differentiation, especially from the functional programming community. As a result there are many recent papers that look at AD from a Category Theory perspective. However, Category Theorists have already been looking at differentiation and calculus in general since the late 60’s in the context of Synthetic Differential Geometry, but it seems that this work is largely ignored by those interested in AD. In this talk, we will provide a gentle introduction to the ideas of SDG, by relating them to dual numbers, and show how it provides a simple and purely algebraic approach to (automatic) differentiation.

https://mcgill.zoom.us/j/89551971819

An article on Viktor: https://blog.jetbrains.com/kotlin/2021/03/viktor-efficient-vectorized-computations-in-kotlin/

I've created Jupyter integration supporting the display of KMath's MST objects.

@Ролан You will probably like this one. A universal multiplatform Gauss-Legendre numerical integration, which could work on

StructureND

.

Current implementation of BigInteger implementation and power is slow so I provided it with corresponding tests: PR .

Operator overload of Nd4j INDArray #kotlindl

@Pavel Gorgulov @zaleslaw I would like to invite you to a public review of our (aniversary #300) PR by @Ролан and his interns: https://github.com/mipt-npm/kmath/pull/300. The PR introduces API and basic multiplatform implementation of tensor algebra. It is huge. Also I would like to start some kind of discusstion about what features do we want from tensors mathematics. Current implementation has one significant benifit, it works on top of generic KMath

StructureND

meaning it is compatible with any other library which have binings for KMath and one could pass those structures around between different implementations (like Viktor for example). @Ролан I also would like for your students to make a public seminar (in English) describing what have they done and sharing their experience.

We just merged Jupyter integration to the KMath

dev

branch.

One of the problems of many big int implementations is that they work extremely slow for not so big numbers.. I think it is a common case when number of really big numbers operations is slow so real numbers can be used with longs in most cases and overflows are rare. So, I created a demo to demonstrate it. I didn't compare with KMath's implementation but compared with java.lang.Math's one. Even when I give no helping info, it is about 4 times faster. When I used explicit

LongBased

type, it became 10 faster than generic one. The speed was the same with just manual long checking. This is because I used inline types. However, it is still a lot slower than just pure usage of

Int

s and `Long`s. But that may be achieved if the code is run under HotSpot and it decides to use intrinsic there. Here is the repo: https://github.com/zhelenskiy/BigInteger/tree/main.