kmath/kmath-ast/README.md

157 lines
5.0 KiB
Markdown
Raw Normal View History

2021-03-22 14:32:08 +03:00
# Module kmath-ast
2020-06-15 11:02:13 +03:00
2021-03-22 14:32:08 +03:00
Abstract syntax tree expression representation and related optimizations.
- [expression-language](src/commonMain/kotlin/space/kscience/kmath/ast/parser.kt) : Expression language and its parser
2021-03-16 22:46:22 +03:00
- [mst-jvm-codegen](src/jvmMain/kotlin/space/kscience/kmath/asm/asm.kt) : Dynamic MST to JVM bytecode compiler
- [mst-js-codegen](src/jsMain/kotlin/space/kscience/kmath/estree/estree.kt) : Dynamic MST to JS compiler
- [rendering](src/commonMain/kotlin/space/kscience/kmath/ast/rendering/MathRenderer.kt) : Extendable MST rendering
2020-12-22 14:02:02 +03:00
2021-03-22 14:32:08 +03:00
## Artifact:
The Maven coordinates of this project are `space.kscience:kmath-ast:0.3.0-dev-7`.
2021-03-22 14:32:08 +03:00
**Gradle:**
```gradle
repositories {
maven { url 'https://repo.kotlin.link' }
mavenCentral()
2021-03-22 14:32:08 +03:00
}
dependencies {
implementation 'space.kscience:kmath-ast:0.3.0-dev-7'
2021-03-22 14:32:08 +03:00
}
```
**Gradle Kotlin DSL:**
```kotlin
repositories {
maven("https://repo.kotlin.link")
mavenCentral()
2021-03-22 14:32:08 +03:00
}
dependencies {
implementation("space.kscience:kmath-ast:0.3.0-dev-7")
2021-03-22 14:32:08 +03:00
}
```
2020-12-22 12:00:51 +03:00
## Dynamic expression code generation
### On JVM
2020-12-22 14:02:02 +03:00
`kmath-ast` JVM module supports runtime code generation to eliminate overhead of tree traversal. Code generator builds
a special implementation of `Expression<T>` with implemented `invoke` function.
2020-12-22 14:02:02 +03:00
For example, the following builder:
```kotlin
MstField { bindSymbol("x") + 2 }.compileToExpression(DoubleField)
```
2021-04-23 04:49:01 +03:00
... leads to generation of bytecode, which can be decompiled to the following Java class:
```java
2021-02-19 10:52:56 +03:00
package space.kscience.kmath.asm.generated;
import java.util.Map;
2020-12-22 12:00:51 +03:00
import kotlin.jvm.functions.Function2;
2021-02-18 11:17:28 +03:00
import space.kscience.kmath.asm.internal.MapIntrinsics;
import space.kscience.kmath.expressions.Expression;
import space.kscience.kmath.expressions.Symbol;
2020-12-22 12:00:51 +03:00
public final class AsmCompiledExpression_45045_0 implements Expression<Double> {
private final Object[] constants;
2021-02-11 19:35:45 +03:00
public final Double invoke(Map<Symbol, ? extends Double> arguments) {
2020-12-22 12:00:51 +03:00
return (Double)((Function2)this.constants[0]).invoke((Double)MapIntrinsics.getOrFail(arguments, "x"), 2);
}
2020-12-22 12:00:51 +03:00
public AsmCompiledExpression_45045_0(Object[] constants) {
this.constants = constants;
}
}
2020-06-26 12:05:13 +03:00
```
2020-12-22 12:00:51 +03:00
#### Known issues
- The same classes may be generated and loaded twice, so it is recommended to cache compiled expressions to avoid
2020-12-22 14:02:02 +03:00
class loading overhead.
- This API is not supported by non-dynamic JVM implementations (like TeaVM and GraalVM) because of using class loaders.
2020-12-22 12:00:51 +03:00
### On JS
A similar feature is also available on JS.
```kotlin
MstField { bindSymbol("x") + 2 }.compileToExpression(DoubleField)
2020-12-22 12:00:51 +03:00
```
The code above returns expression implemented with such a JS function:
```js
var executable = function (constants, arguments) {
return constants[1](constants[0](arguments, "x"), 2);
};
```
2021-04-23 04:49:01 +03:00
JS also supports very experimental expression optimization with [WebAssembly](https://webassembly.org/) IR generation. Currently, only expressions inside `DoubleField` and `IntRing` are supported.
```kotlin
import space.kscience.kmath.wasm.*
MstField { bindSymbol("x") + 2 }.compileToExpression(DoubleField)
```
2021-04-23 04:49:01 +03:00
An example of emitted Wasm IR in the form of WAT:
```lisp
(func $executable (param $0 f64) (result f64)
(f64.add
(local.get $0)
(f64.const 2)
)
)
```
2020-12-22 12:00:51 +03:00
#### Known issues
- ESTree expression compilation uses `eval` which can be unavailable in several environments.
- WebAssembly isn't supported by old versions of browsers (see https://webassembly.org/roadmap/).
2021-03-25 19:57:47 +03:00
## Rendering expressions
kmath-ast also includes an extensible engine to display expressions in LaTeX or MathML syntax.
2021-03-25 19:57:47 +03:00
Example usage:
```kotlin
import space.kscience.kmath.ast.*
import space.kscience.kmath.ast.rendering.*
public fun main() {
val mst = "exp(sqrt(x))-asin(2*x)/(2e10+x^3)/(-12)".parseMath()
val syntax = FeaturedMathRendererWithPostProcess.Default.render(mst)
val latex = LatexSyntaxRenderer.renderWithStringBuilder(syntax)
println("LaTeX:")
println(latex)
println()
val mathML = MathMLSyntaxRenderer.renderWithStringBuilder(syntax)
println("MathML:")
println(mathML)
}
```
Result LaTeX:
2021-03-25 19:57:47 +03:00
![](http://chart.googleapis.com/chart?cht=tx&chl=e%5E%7B%5Csqrt%7Bx%7D%7D-%5Cfrac%7B%5Cfrac%7B%5Coperatorname%7Bsin%7D%5E%7B-1%7D%5C,%5Cleft(2%5C,x%5Cright)%7D%7B2%5Ctimes10%5E%7B10%7D%2Bx%5E%7B3%7D%7D%7D%7B-12%7D)
Result MathML (embedding MathML is not allowed by GitHub Markdown):
```html
<mrow><msup><mrow><mi>e</mi></mrow><mrow><msqrt><mi>x</mi></msqrt></mrow></msup><mo>-</mo><mfrac><mrow><mfrac><mrow><msup><mrow><mo>sin</mo></mrow><mrow><mo>-</mo><mn>1</mn></mrow></msup><mspace width="0.167em"></mspace><mfenced open="(" close=")" separators=""><mn>2</mn><mspace width="0.167em"></mspace><mi>x</mi></mfenced></mrow><mrow><mn>2</mn><mo>&times;</mo><msup><mrow><mn>10</mn></mrow><mrow><mn>10</mn></mrow></msup><mo>+</mo><msup><mrow><mi>x</mi></mrow><mrow><mn>3</mn></mrow></msup></mrow></mfrac></mrow><mrow><mo>-</mo><mn>12</mn></mrow></mfrac></mrow>
```
It is also possible to create custom algorithms of render, and even add support of other markup languages
2021-03-25 19:57:47 +03:00
(see API reference).