Flexible and modular mathematics library designed for advanced numerical operations, algebraic structures, and linear algebra. Features modularity, support for various mathematical domains, and integration with optimized platform libraries.
Surfaced from shared tags and platforms — no rankings paid for.
Could be pronounced as key-math. The Kotlin Mathematics library was initially intended as a Kotlin-based analog to Python's NumPy library. Later we found that kotlin is a much more flexible language and allows superior architecture designs. In contrast to numpy and scipy it is modular and has a lightweight core. The numpy-like experience could be achieved with kmath-for-real extension module.
Float64 in the core. For that we will have specialization modules like kmath-for-real, which will give a better experience for those who want to work with specific types.The project requires a lot of additional work. The most important thing we need is feedback about what features are required the most. Feel free to create feature requests. We are also welcome to code contributions, especially in issues marked with good first issue label.
Project roadmap will be available at GitHub Projects.
KMath is a modular library. Different modules provide different features with different API stability guarantees. All core modules are released with the same version, but with different API change policy. The features are described in module definitions below. The module stability could have the following levels:
@UnstableKMathAPI or other stability warning annotations.Maturity: EXPERIMENTAL
Maturity: EXPERIMENTAL
Features:
- expression-language : Expression language and its parser
Commons math binding for kmath
Maturity: EXPERIMENTAL
Complex numbers and quaternions.
Maturity: PROTOTYPE
Features:
- complex : Complex numbers operations
- quaternion : Quaternions and their composition
Maturity: EXPERIMENTAL
A proof of concept module for adding type-safe dimensions to structures
Maturity: PROTOTYPE
Maturity: PROTOTYPE
Features:
- ejml-vector : Point implementations.
- ejml-matrix : Matrix implementation.
- ejml-linear-space : LinearSpace implementations.
Extension module that should be used to achieve numpy-like behavior. All operations are specialized to work with
Doublenumbers without declaring algebraic contexts. One can still use generic algebras though.
Maturity: PROTOTYPE
Maturity: PROTOTYPE
Maturity: PROTOTYPE
Kotlin∇ integration module
Maturity: EXPERIMENTAL
Features:
- differentiable-mst-expression : MST based DifferentiableExpression.
- scalars-adapters : Conversions between Kotlin∇'s SFun and MST
An API and basic implementation for arranging objects in a continuous memory block.
Maturity: DEVELOPMENT
JetBrains Multik connector
Maturity: PROTOTYPE
Ojalgo bindings for kmath
Maturity: PROTOTYPE
Maturity: EXPERIMENTAL
Maturity: EXPERIMENTAL
Symja integration module
Maturity: PROTOTYPE
Google tensorflow connector
Maturity: PROTOTYPE
Maturity: PROTOTYPE
Features:
- tensor algebra : Basic linear algebra operations on tensors (plus, dot, etc.)
- tensor algebra with broadcasting : Basic linear algebra operations implemented with broadcasting.
Binding for https://github.com/JetBrains-Research/viktor
Maturity: DEPRECATED
Maturity: EXPERIMENTAL
KMath is developed as a multi-platform library, which means that most of the interfaces are declared in common source sets like common source sets and implemented there wherever it is possible. In some cases, features are delegated to platform-specific implementations even if they could be provided in the common module for performance reasons. Currently, Kotlin/JVM is the primary platform, however, Kotlin/Native, Kotlin/JS and Kotlin/Wasm contributions and feedback are also welcome.
Performance of mathematical operations is hard to achieve without a lot of effort. KMath focus is to provide a reasonable performance for common cases, out of the box and good interoperability with optimized libraries for edge cases. For example, one could prototype an algorithm using KMath core implementations and then use Multik or Ojalgo for performance-critical parts just by adding a dependency and algebra context switch.
As for core implementations, we expect to focus on creating a convenient universal API first and then work on increasing performance for specific cases. We expect the worst KMath benchmarks will perform better than native Python, but worse than optimized native/SciPy (mostly due to boxing operations on primitive numbers). The best performance of optimized parts could be better than SciPy.
KMath currently relies on JDK 21 for compilation and execution of Kotlin-JVM part.
Intermediate releases are published to Kotlin.Link repository.
repositories {
maven("https://repo.kotlin.link")
}
dependencies {
api("space.kscience:kmath-core:$version")
// api("space.kscience:kmath-core-jvm:$version") for jvm-specific version
}
Core classes, algebra definitions, basic linear algebra
Maturity: DEVELOPMENT
Features:
Space API.LinearAlgebraMaturity: EXPERIMENTAL
Features:
Functions, integration and interpolation
Maturity: EXPERIMENTAL
Features: