kmath/kmath-ast

Module kmath-ast

Abstract syntax tree expression representation and related optimizations.

• expression-language : Expression language and its parser
• mst-jvm-codegen : Dynamic MST to JVM bytecode compiler
• mst-js-codegen : Dynamic MST to JS compiler
• rendering : Extendable MST rendering

Artifact:

The Maven coordinates of this project are space.kscience:kmath-ast:0.3.0-dev-7.

Gradle:

repositories {
    maven { url 'https://repo.kotlin.link' }
    mavenCentral()
}

dependencies {
    implementation 'space.kscience:kmath-ast:0.3.0-dev-7'
}

Gradle Kotlin DSL:

repositories {
    maven("https://repo.kotlin.link")
    mavenCentral()
}

dependencies {
    implementation("space.kscience:kmath-ast:0.3.0-dev-7")
}

Dynamic expression code generation

On JVM

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.

For example, the following builder:

MstField { bindSymbol("x") + 2 }.compileToExpression(DoubleField)

... leads to generation of bytecode, which can be decompiled to the following Java class:

package space.kscience.kmath.asm.generated;

import java.util.Map;
import kotlin.jvm.functions.Function2;
import space.kscience.kmath.asm.internal.MapIntrinsics;
import space.kscience.kmath.expressions.Expression;
import space.kscience.kmath.expressions.Symbol;

public final class AsmCompiledExpression_45045_0 implements Expression<Double> {
    private final Object[] constants;

    public final Double invoke(Map<Symbol, ? extends Double> arguments) {
        return (Double)((Function2)this.constants[0]).invoke((Double)MapIntrinsics.getOrFail(arguments, "x"), 2);
    }

    public AsmCompiledExpression_45045_0(Object[] constants) {
        this.constants = constants;
    }
}

Known issues

• The same classes may be generated and loaded twice, so it is recommended to cache compiled expressions to avoid class loading overhead.
• This API is not supported by non-dynamic JVM implementations (like TeaVM and GraalVM) because of using class loaders.

On JS

A similar feature is also available on JS.

MstField { bindSymbol("x") + 2 }.compileToExpression(DoubleField)

The code above returns expression implemented with such a JS function:

var executable = function (constants, arguments) {
  return constants[1](constants[0](arguments, "x"), 2);
};

JS also supports very experimental expression optimization with WebAssembly IR generation. Currently, only expressions inside DoubleField and IntRing are supported.

import space.kscience.kmath.wasm.*

MstField { bindSymbol("x") + 2 }.compileToExpression(DoubleField)

An example of emitted Wasm IR in the form of WAT:

(func $executable (param $0 f64) (result f64)
  (f64.add
    (local.get $0)
    (f64.const 2)
  )
)

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/).

Rendering expressions

kmath-ast also includes an extensible engine to display expressions in LaTeX or MathML syntax.

Example usage:

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:

Result MathML (embedding MathML is not allowed by GitHub Markdown):

<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 (see API reference).