{
A similar feature is also available on JS.
```kotlin
+import space.kscience.kmath.expressions.Symbol.Companion.x
import space.kscience.kmath.expressions.*
import space.kscience.kmath.operations.*
import space.kscience.kmath.estree.*
-MstField { bindSymbol("x") + 2 }.compileToExpression(DoubleField)
+MstField { x + 2 }.compileToExpression(DoubleField)
```
The code above returns expression implemented with such a JS function:
@@ -104,15 +106,16 @@ var executable = function (constants, arguments) {
};
```
-JS also supports very experimental expression optimization with [WebAssembly](https://webassembly.org/) IR generation.
+JS also supports experimental expression optimization with [WebAssembly](https://webassembly.org/) IR generation.
Currently, only expressions inside `DoubleField` and `IntRing` are supported.
```kotlin
+import space.kscience.kmath.expressions.Symbol.Companion.x
import space.kscience.kmath.expressions.*
import space.kscience.kmath.operations.*
import space.kscience.kmath.wasm.*
-MstField { bindSymbol("x") + 2 }.compileToExpression(DoubleField)
+MstField { x + 2 }.compileToExpression(DoubleField)
```
An example of emitted Wasm IR in the form of WAT:
@@ -158,7 +161,10 @@ public fun main() {
Result LaTeX:
+
+
-%5Cfrac{%5Cfrac{%5Coperatorname{arcsin}%5C,%5Cleft(2%5C,x%5Cright)}{2%5Ctimes10^{10}%2Bx^{3}}}{12}+x^{2/3})
+
Result MathML (can be used with MathJax or other renderers):
diff --git a/kmath-ast/build.gradle.kts b/kmath-ast/build.gradle.kts
index 508374d82..9de7e9980 100644
--- a/kmath-ast/build.gradle.kts
+++ b/kmath-ast/build.gradle.kts
@@ -37,17 +37,15 @@ kotlin.sourceSets {
jsMain {
dependencies {
- implementation(npm("astring", "1.7.4"))
- implementation(npm("binaryen", "100.0"))
- implementation(npm("js-base64", "3.6.0"))
- implementation(npm("webassembly", "0.11.0"))
+ implementation(npm("astring", "1.7.5"))
+ implementation(npm("binaryen", "101.0.0"))
+ implementation(npm("js-base64", "3.6.1"))
}
}
jvmMain {
dependencies {
- implementation("org.ow2.asm:asm:9.1")
- implementation("org.ow2.asm:asm-commons:9.1")
+ implementation("org.ow2.asm:asm-commons:9.2")
}
}
}
@@ -63,25 +61,21 @@ readme {
feature(
id = "expression-language",
- description = "Expression language and its parser",
ref = "src/commonMain/kotlin/space/kscience/kmath/ast/parser.kt"
- )
+ ) { "Expression language and its parser" }
feature(
id = "mst-jvm-codegen",
- description = "Dynamic MST to JVM bytecode compiler",
ref = "src/jvmMain/kotlin/space/kscience/kmath/asm/asm.kt"
- )
+ ) { "Dynamic MST to JVM bytecode compiler" }
feature(
id = "mst-js-codegen",
- description = "Dynamic MST to JS compiler",
ref = "src/jsMain/kotlin/space/kscience/kmath/estree/estree.kt"
- )
+ ) { "Dynamic MST to JS compiler" }
feature(
id = "rendering",
- description = "Extendable MST rendering",
ref = "src/commonMain/kotlin/space/kscience/kmath/ast/rendering/MathRenderer.kt"
- )
+ ) { "Extendable MST rendering" }
}
diff --git a/kmath-ast/docs/README-TEMPLATE.md b/kmath-ast/docs/README-TEMPLATE.md
index 80ea31642..9494af63a 100644
--- a/kmath-ast/docs/README-TEMPLATE.md
+++ b/kmath-ast/docs/README-TEMPLATE.md
@@ -16,11 +16,12 @@ special implementation of `Expression` with implemented `invoke` function.
For example, the following builder:
```kotlin
+import space.kscience.kmath.expressions.Symbol.Companion.x
import space.kscience.kmath.expressions.*
import space.kscience.kmath.operations.*
import space.kscience.kmath.asm.*
-MstField { bindSymbol("x") + 2 }.compileToExpression(DoubleField)
+MstField { x + 2 }.compileToExpression(DoubleField)
```
... leads to generation of bytecode, which can be decompiled to the following Java class:
@@ -60,11 +61,12 @@ public final class AsmCompiledExpression_45045_0 implements Expression {
A similar feature is also available on JS.
```kotlin
+import space.kscience.kmath.expressions.Symbol.Companion.x
import space.kscience.kmath.expressions.*
import space.kscience.kmath.operations.*
import space.kscience.kmath.estree.*
-MstField { bindSymbol("x") + 2 }.compileToExpression(DoubleField)
+MstField { x + 2 }.compileToExpression(DoubleField)
```
The code above returns expression implemented with such a JS function:
@@ -75,15 +77,16 @@ var executable = function (constants, arguments) {
};
```
-JS also supports very experimental expression optimization with [WebAssembly](https://webassembly.org/) IR generation.
+JS also supports experimental expression optimization with [WebAssembly](https://webassembly.org/) IR generation.
Currently, only expressions inside `DoubleField` and `IntRing` are supported.
```kotlin
+import space.kscience.kmath.expressions.Symbol.Companion.x
import space.kscience.kmath.expressions.*
import space.kscience.kmath.operations.*
import space.kscience.kmath.wasm.*
-MstField { bindSymbol("x") + 2 }.compileToExpression(DoubleField)
+MstField { x + 2 }.compileToExpression(DoubleField)
```
An example of emitted Wasm IR in the form of WAT:
@@ -129,7 +132,10 @@ public fun main() {
Result LaTeX:
+
+
-%5Cfrac{%5Cfrac{%5Coperatorname{arcsin}%5C,%5Cleft(2%5C,x%5Cright)}{2%5Ctimes10^{10}%2Bx^{3}}}{12}+x^{2/3})
+
Result MathML (can be used with MathJax or other renderers):
diff --git a/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/LatexSyntaxRenderer.kt b/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/LatexSyntaxRenderer.kt
index 01717b0f9..2df3d3cc7 100644
--- a/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/LatexSyntaxRenderer.kt
+++ b/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/LatexSyntaxRenderer.kt
@@ -27,7 +27,7 @@ import space.kscience.kmath.misc.UnstableKMathAPI
*/
@UnstableKMathAPI
public object LatexSyntaxRenderer : SyntaxRenderer {
- public override fun render(node: MathSyntax, output: Appendable): Unit = output.run {
+ override fun render(node: MathSyntax, output: Appendable): Unit = output.run {
fun render(syntax: MathSyntax) = render(syntax, output)
when (node) {
diff --git a/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/MathMLSyntaxRenderer.kt b/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/MathMLSyntaxRenderer.kt
index cda8e2322..8b5819b84 100644
--- a/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/MathMLSyntaxRenderer.kt
+++ b/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/MathMLSyntaxRenderer.kt
@@ -16,7 +16,7 @@ import space.kscience.kmath.misc.UnstableKMathAPI
*/
@UnstableKMathAPI
public object MathMLSyntaxRenderer : SyntaxRenderer {
- public override fun render(node: MathSyntax, output: Appendable) {
+ override fun render(node: MathSyntax, output: Appendable) {
output.append("")
diff --git a/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/MathRenderer.kt b/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/MathRenderer.kt
index c33f95483..fdef35ebd 100644
--- a/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/MathRenderer.kt
+++ b/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/MathRenderer.kt
@@ -29,7 +29,7 @@ public fun interface MathRenderer {
*/
@UnstableKMathAPI
public open class FeaturedMathRenderer(public val features: List) : MathRenderer {
- public override fun render(mst: MST): MathSyntax {
+ override fun render(mst: MST): MathSyntax {
for (feature in features) feature.render(this, mst)?.let { return it }
throw UnsupportedOperationException("Renderer $this has no appropriate feature to render node $mst.")
}
@@ -54,9 +54,9 @@ public open class FeaturedMathRenderer(public val features: List)
@UnstableKMathAPI
public open class FeaturedMathRendererWithPostProcess(
features: List,
- public val stages: List,
+ public val stages: List,
) : FeaturedMathRenderer(features) {
- public override fun render(mst: MST): MathSyntax {
+ override fun render(mst: MST): MathSyntax {
val res = super.render(mst)
for (stage in stages) stage.perform(res)
return res
@@ -65,7 +65,7 @@ public open class FeaturedMathRendererWithPostProcess(
/**
* Logical unit of [MathSyntax] post-processing.
*/
- public fun interface PostProcessStage {
+ public fun interface PostProcessPhase {
/**
* Performs the specified action over [MathSyntax].
*/
@@ -102,7 +102,7 @@ public open class FeaturedMathRendererWithPostProcess(
// Printing terminal nodes as string
PrintNumeric,
- PrintSymbolic,
+ PrintSymbol,
),
listOf(
BetterExponent,
diff --git a/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/MathSyntax.kt b/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/MathSyntax.kt
index a71985fbc..ee23ab408 100644
--- a/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/MathSyntax.kt
+++ b/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/MathSyntax.kt
@@ -8,7 +8,7 @@ package space.kscience.kmath.ast.rendering
import space.kscience.kmath.misc.UnstableKMathAPI
/**
- * Mathematical typography syntax node.
+ * Syntax node for mathematical typography.
*
* @author Iaroslav Postovalov
*/
@@ -150,9 +150,9 @@ public data class OperandSyntax(
*/
@UnstableKMathAPI
public data class UnaryOperatorSyntax(
- public override val operation: String,
+ override val operation: String,
public var prefix: MathSyntax,
- public override val operand: OperandSyntax,
+ override val operand: OperandSyntax,
) : UnarySyntax() {
init {
operand.parent = this
@@ -166,8 +166,8 @@ public data class UnaryOperatorSyntax(
*/
@UnstableKMathAPI
public data class UnaryPlusSyntax(
- public override val operation: String,
- public override val operand: OperandSyntax,
+ override val operation: String,
+ override val operand: OperandSyntax,
) : UnarySyntax() {
init {
operand.parent = this
@@ -181,8 +181,8 @@ public data class UnaryPlusSyntax(
*/
@UnstableKMathAPI
public data class UnaryMinusSyntax(
- public override val operation: String,
- public override val operand: OperandSyntax,
+ override val operation: String,
+ override val operand: OperandSyntax,
) : UnarySyntax() {
init {
operand.parent = this
@@ -197,8 +197,8 @@ public data class UnaryMinusSyntax(
*/
@UnstableKMathAPI
public data class RadicalSyntax(
- public override val operation: String,
- public override val operand: MathSyntax,
+ override val operation: String,
+ override val operand: MathSyntax,
) : UnarySyntax() {
init {
operand.parent = this
@@ -215,8 +215,8 @@ public data class RadicalSyntax(
*/
@UnstableKMathAPI
public data class ExponentSyntax(
- public override val operation: String,
- public override val operand: OperandSyntax,
+ override val operation: String,
+ override val operand: OperandSyntax,
public var useOperatorForm: Boolean,
) : UnarySyntax() {
init {
@@ -233,9 +233,9 @@ public data class ExponentSyntax(
*/
@UnstableKMathAPI
public data class SuperscriptSyntax(
- public override val operation: String,
- public override val left: MathSyntax,
- public override val right: MathSyntax,
+ override val operation: String,
+ override val left: MathSyntax,
+ override val right: MathSyntax,
) : BinarySyntax() {
init {
left.parent = this
@@ -252,9 +252,9 @@ public data class SuperscriptSyntax(
*/
@UnstableKMathAPI
public data class SubscriptSyntax(
- public override val operation: String,
- public override val left: MathSyntax,
- public override val right: MathSyntax,
+ override val operation: String,
+ override val left: MathSyntax,
+ override val right: MathSyntax,
) : BinarySyntax() {
init {
left.parent = this
@@ -270,10 +270,10 @@ public data class SubscriptSyntax(
*/
@UnstableKMathAPI
public data class BinaryOperatorSyntax(
- public override val operation: String,
+ override val operation: String,
public var prefix: MathSyntax,
- public override val left: MathSyntax,
- public override val right: MathSyntax,
+ override val left: MathSyntax,
+ override val right: MathSyntax,
) : BinarySyntax() {
init {
left.parent = this
@@ -290,9 +290,9 @@ public data class BinaryOperatorSyntax(
*/
@UnstableKMathAPI
public data class BinaryPlusSyntax(
- public override val operation: String,
- public override val left: OperandSyntax,
- public override val right: OperandSyntax,
+ override val operation: String,
+ override val left: OperandSyntax,
+ override val right: OperandSyntax,
) : BinarySyntax() {
init {
left.parent = this
@@ -301,7 +301,7 @@ public data class BinaryPlusSyntax(
}
/**
- * Represents binary, infix subtraction (*42 - 42*).
+ * Represents binary, infix subtraction (*42 − 42*).
*
* @param left The minuend.
* @param right The subtrahend.
@@ -309,9 +309,9 @@ public data class BinaryPlusSyntax(
*/
@UnstableKMathAPI
public data class BinaryMinusSyntax(
- public override val operation: String,
- public override val left: OperandSyntax,
- public override val right: OperandSyntax,
+ override val operation: String,
+ override val left: OperandSyntax,
+ override val right: OperandSyntax,
) : BinarySyntax() {
init {
left.parent = this
@@ -329,9 +329,9 @@ public data class BinaryMinusSyntax(
*/
@UnstableKMathAPI
public data class FractionSyntax(
- public override val operation: String,
- public override val left: OperandSyntax,
- public override val right: OperandSyntax,
+ override val operation: String,
+ override val left: OperandSyntax,
+ override val right: OperandSyntax,
public var infix: Boolean,
) : BinarySyntax() {
init {
@@ -349,9 +349,9 @@ public data class FractionSyntax(
*/
@UnstableKMathAPI
public data class RadicalWithIndexSyntax(
- public override val operation: String,
- public override val left: MathSyntax,
- public override val right: MathSyntax,
+ override val operation: String,
+ override val left: MathSyntax,
+ override val right: MathSyntax,
) : BinarySyntax() {
init {
left.parent = this
@@ -369,9 +369,9 @@ public data class RadicalWithIndexSyntax(
*/
@UnstableKMathAPI
public data class MultiplicationSyntax(
- public override val operation: String,
- public override val left: OperandSyntax,
- public override val right: OperandSyntax,
+ override val operation: String,
+ override val left: OperandSyntax,
+ override val right: OperandSyntax,
public var times: Boolean,
) : BinarySyntax() {
init {
diff --git a/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/SyntaxRenderer.kt b/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/SyntaxRenderer.kt
index fb2b3b66f..362c07d72 100644
--- a/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/SyntaxRenderer.kt
+++ b/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/SyntaxRenderer.kt
@@ -9,7 +9,7 @@ import space.kscience.kmath.misc.UnstableKMathAPI
/**
* Abstraction of writing [MathSyntax] as a string of an actual markup language. Typical implementation should
- * involve traversal of MathSyntax with handling each its subtype.
+ * involve traversal of MathSyntax with handling each subtype.
*
* @author Iaroslav Postovalov
*/
diff --git a/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/features.kt b/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/features.kt
index 863825799..8a4804916 100644
--- a/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/features.kt
+++ b/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/features.kt
@@ -13,15 +13,14 @@ import space.kscience.kmath.operations.*
import kotlin.reflect.KClass
/**
- * Prints any [MST.Symbolic] as a [SymbolSyntax] containing the [MST.Symbolic.value] of it.
+ * Prints any [Symbol] as a [SymbolSyntax] containing the [Symbol.identity] of it.
*
* @author Iaroslav Postovalov
*/
@UnstableKMathAPI
-public object PrintSymbolic : RenderFeature {
- public override fun render(renderer: FeaturedMathRenderer, node: MST): SymbolSyntax? =
- if (node !is Symbol) null
- else SymbolSyntax(string = node.identity)
+public val PrintSymbol: RenderFeature = RenderFeature { _, node ->
+ if (node !is Symbol) null
+ else SymbolSyntax(string = node.identity)
}
/**
@@ -30,8 +29,8 @@ public object PrintSymbolic : RenderFeature {
* @author Iaroslav Postovalov
*/
@UnstableKMathAPI
-public object PrintNumeric : RenderFeature {
- public override fun render(renderer: FeaturedMathRenderer, node: MST): NumberSyntax? = if (node !is MST.Numeric)
+public val PrintNumeric: RenderFeature = RenderFeature { _, node ->
+ if (node !is MST.Numeric)
null
else
NumberSyntax(string = node.value.toString())
@@ -50,7 +49,7 @@ else
NumberSyntax(string = s)
/**
- * Special printing for numeric types which are printed in form of
+ * Special printing for numeric types that are printed in form of
* *('-'? (DIGIT+ ('.' DIGIT+)? ('E' '-'? DIGIT+)? | 'Infinity')) | 'NaN'*.
*
* @property types The suitable types.
@@ -58,7 +57,7 @@ else
*/
@UnstableKMathAPI
public class PrettyPrintFloats(public val types: Set>) : RenderFeature {
- public override fun render(renderer: FeaturedMathRenderer, node: MST): MathSyntax? {
+ override fun render(renderer: FeaturedMathRenderer, node: MST): MathSyntax? {
if (node !is MST.Numeric || node.value::class !in types) return null
val toString = when (val v = node.value) {
@@ -111,14 +110,14 @@ public class PrettyPrintFloats(public val types: Set>) : Rend
}
/**
- * Special printing for numeric types which are printed in form of *'-'? DIGIT+*.
+ * Special printing for numeric types that are printed in form of *'-'? DIGIT+*.
*
* @property types The suitable types.
* @author Iaroslav Postovalov
*/
@UnstableKMathAPI
public class PrettyPrintIntegers(public val types: Set>) : RenderFeature {
- public override fun render(renderer: FeaturedMathRenderer, node: MST): MathSyntax? =
+ override fun render(renderer: FeaturedMathRenderer, node: MST): MathSyntax? =
if (node !is MST.Numeric || node.value::class !in types)
null
else
@@ -141,7 +140,7 @@ public class PrettyPrintIntegers(public val types: Set>) : Re
*/
@UnstableKMathAPI
public class PrettyPrintPi(public val symbols: Set) : RenderFeature {
- public override fun render(renderer: FeaturedMathRenderer, node: MST): SpecialSymbolSyntax? =
+ override fun render(renderer: FeaturedMathRenderer, node: MST): MathSyntax? =
if (node !is Symbol || node.identity !in symbols)
null
else
@@ -156,7 +155,7 @@ public class PrettyPrintPi(public val symbols: Set) : RenderFeature {
}
/**
- * Abstract printing of unary operations which discards [MST] if their operation is not in [operations] or its type is
+ * Abstract printing of unary operations that discards [MST] if their operation is not in [operations] or its type is
* not [MST.Unary].
*
* @param operations the allowed operations. If `null`, any operation is accepted.
@@ -177,7 +176,7 @@ public abstract class Unary(public val operations: Collection?) : Render
}
/**
- * Abstract printing of unary operations which discards [MST] if their operation is not in [operations] or its type is
+ * Abstract printing of unary operations that discards [MST] if their operation is not in [operations] or its type is
* not [MST.Binary].
*
* @property operations the allowed operations. If `null`, any operation is accepted.
@@ -203,7 +202,7 @@ public abstract class Binary(public val operations: Collection?) : Rende
*/
@UnstableKMathAPI
public class BinaryPlus(operations: Collection?) : Binary(operations) {
- public override fun renderBinary(parent: FeaturedMathRenderer, node: MST.Binary): BinaryPlusSyntax =
+ override fun renderBinary(parent: FeaturedMathRenderer, node: MST.Binary): MathSyntax =
BinaryPlusSyntax(
operation = node.operation,
left = OperandSyntax(parent.render(node.left), true),
@@ -225,7 +224,7 @@ public class BinaryPlus(operations: Collection?) : Binary(operations) {
*/
@UnstableKMathAPI
public class BinaryMinus(operations: Collection?) : Binary(operations) {
- public override fun renderBinary(parent: FeaturedMathRenderer, node: MST.Binary): BinaryMinusSyntax =
+ override fun renderBinary(parent: FeaturedMathRenderer, node: MST.Binary): MathSyntax =
BinaryMinusSyntax(
operation = node.operation,
left = OperandSyntax(operand = parent.render(node.left), parentheses = true),
@@ -247,7 +246,7 @@ public class BinaryMinus(operations: Collection?) : Binary(operations) {
*/
@UnstableKMathAPI
public class UnaryPlus(operations: Collection?) : Unary(operations) {
- public override fun renderUnary(parent: FeaturedMathRenderer, node: MST.Unary): UnaryPlusSyntax = UnaryPlusSyntax(
+ override fun renderUnary(parent: FeaturedMathRenderer, node: MST.Unary): MathSyntax = UnaryPlusSyntax(
operation = node.operation,
operand = OperandSyntax(operand = parent.render(node.value), parentheses = true),
)
@@ -267,7 +266,7 @@ public class UnaryPlus(operations: Collection?) : Unary(operations) {
*/
@UnstableKMathAPI
public class UnaryMinus(operations: Collection?) : Unary(operations) {
- public override fun renderUnary(parent: FeaturedMathRenderer, node: MST.Unary): UnaryMinusSyntax = UnaryMinusSyntax(
+ override fun renderUnary(parent: FeaturedMathRenderer, node: MST.Unary): MathSyntax = UnaryMinusSyntax(
operation = node.operation,
operand = OperandSyntax(operand = parent.render(node.value), parentheses = true),
)
@@ -287,7 +286,7 @@ public class UnaryMinus(operations: Collection?) : Unary(operations) {
*/
@UnstableKMathAPI
public class Fraction(operations: Collection?) : Binary(operations) {
- public override fun renderBinary(parent: FeaturedMathRenderer, node: MST.Binary): FractionSyntax = FractionSyntax(
+ override fun renderBinary(parent: FeaturedMathRenderer, node: MST.Binary): MathSyntax = FractionSyntax(
operation = node.operation,
left = OperandSyntax(operand = parent.render(node.left), parentheses = true),
right = OperandSyntax(operand = parent.render(node.right), parentheses = true),
@@ -309,7 +308,7 @@ public class Fraction(operations: Collection?) : Binary(operations) {
*/
@UnstableKMathAPI
public class BinaryOperator(operations: Collection?) : Binary(operations) {
- public override fun renderBinary(parent: FeaturedMathRenderer, node: MST.Binary): BinaryOperatorSyntax =
+ override fun renderBinary(parent: FeaturedMathRenderer, node: MST.Binary): MathSyntax =
BinaryOperatorSyntax(
operation = node.operation,
prefix = OperatorNameSyntax(name = node.operation),
@@ -332,7 +331,7 @@ public class BinaryOperator(operations: Collection?) : Binary(operations
*/
@UnstableKMathAPI
public class UnaryOperator(operations: Collection?) : Unary(operations) {
- public override fun renderUnary(parent: FeaturedMathRenderer, node: MST.Unary): UnaryOperatorSyntax =
+ override fun renderUnary(parent: FeaturedMathRenderer, node: MST.Unary): MathSyntax =
UnaryOperatorSyntax(
operation = node.operation,
prefix = OperatorNameSyntax(node.operation),
@@ -354,7 +353,7 @@ public class UnaryOperator(operations: Collection?) : Unary(operations)
*/
@UnstableKMathAPI
public class Power(operations: Collection?) : Binary(operations) {
- public override fun renderBinary(parent: FeaturedMathRenderer, node: MST.Binary): SuperscriptSyntax =
+ override fun renderBinary(parent: FeaturedMathRenderer, node: MST.Binary): MathSyntax =
SuperscriptSyntax(
operation = node.operation,
left = OperandSyntax(parent.render(node.left), true),
@@ -374,7 +373,7 @@ public class Power(operations: Collection?) : Binary(operations) {
*/
@UnstableKMathAPI
public class SquareRoot(operations: Collection?) : Unary(operations) {
- public override fun renderUnary(parent: FeaturedMathRenderer, node: MST.Unary): RadicalSyntax =
+ override fun renderUnary(parent: FeaturedMathRenderer, node: MST.Unary): MathSyntax =
RadicalSyntax(operation = node.operation, operand = parent.render(node.value))
public companion object {
@@ -392,7 +391,7 @@ public class SquareRoot(operations: Collection?) : Unary(operations) {
*/
@UnstableKMathAPI
public class Exponent(operations: Collection?) : Unary(operations) {
- public override fun renderUnary(parent: FeaturedMathRenderer, node: MST.Unary): ExponentSyntax = ExponentSyntax(
+ override fun renderUnary(parent: FeaturedMathRenderer, node: MST.Unary): MathSyntax = ExponentSyntax(
operation = node.operation,
operand = OperandSyntax(operand = parent.render(node.value), parentheses = true),
useOperatorForm = true,
@@ -413,7 +412,7 @@ public class Exponent(operations: Collection?) : Unary(operations) {
*/
@UnstableKMathAPI
public class Multiplication(operations: Collection?) : Binary(operations) {
- public override fun renderBinary(parent: FeaturedMathRenderer, node: MST.Binary): MultiplicationSyntax =
+ override fun renderBinary(parent: FeaturedMathRenderer, node: MST.Binary): MathSyntax =
MultiplicationSyntax(
operation = node.operation,
left = OperandSyntax(operand = parent.render(node.left), parentheses = true),
@@ -436,7 +435,7 @@ public class Multiplication(operations: Collection?) : Binary(operations
*/
@UnstableKMathAPI
public class InverseTrigonometricOperations(operations: Collection?) : Unary(operations) {
- public override fun renderUnary(parent: FeaturedMathRenderer, node: MST.Unary): UnaryOperatorSyntax =
+ override fun renderUnary(parent: FeaturedMathRenderer, node: MST.Unary): MathSyntax =
UnaryOperatorSyntax(
operation = node.operation,
prefix = OperatorNameSyntax(name = node.operation.replaceFirst("a", "arc")),
@@ -463,7 +462,7 @@ public class InverseTrigonometricOperations(operations: Collection?) : U
*/
@UnstableKMathAPI
public class InverseHyperbolicOperations(operations: Collection?) : Unary(operations) {
- public override fun renderUnary(parent: FeaturedMathRenderer, node: MST.Unary): UnaryOperatorSyntax =
+ override fun renderUnary(parent: FeaturedMathRenderer, node: MST.Unary): MathSyntax =
UnaryOperatorSyntax(
operation = node.operation,
prefix = OperatorNameSyntax(name = node.operation.replaceFirst("a", "ar")),
diff --git a/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/stages.kt b/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/phases.kt
similarity index 75%
rename from kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/stages.kt
rename to kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/phases.kt
index 1f31af853..574bb54f4 100644
--- a/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/stages.kt
+++ b/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/phases.kt
@@ -5,6 +5,7 @@
package space.kscience.kmath.ast.rendering
+import space.kscience.kmath.ast.rendering.FeaturedMathRendererWithPostProcess.PostProcessPhase
import space.kscience.kmath.misc.UnstableKMathAPI
import space.kscience.kmath.operations.FieldOperations
import space.kscience.kmath.operations.GroupOperations
@@ -17,8 +18,8 @@ import space.kscience.kmath.operations.RingOperations
* @author Iaroslav Postovalov
*/
@UnstableKMathAPI
-public object BetterMultiplication : FeaturedMathRendererWithPostProcess.PostProcessStage {
- public override fun perform(node: MathSyntax): Unit = when (node) {
+public val BetterMultiplication: PostProcessPhase = PostProcessPhase { node ->
+ fun perform(node: MathSyntax): Unit = when (node) {
is NumberSyntax -> Unit
is SymbolSyntax -> Unit
is OperatorNameSyntax -> Unit
@@ -81,6 +82,8 @@ public object BetterMultiplication : FeaturedMathRendererWithPostProcess.PostPro
perform(node.right)
}
}
+
+ perform(node)
}
/**
@@ -89,68 +92,68 @@ public object BetterMultiplication : FeaturedMathRendererWithPostProcess.PostPro
* @author Iaroslav Postovalov
*/
@UnstableKMathAPI
-public object BetterFraction : FeaturedMathRendererWithPostProcess.PostProcessStage {
- private fun perform0(node: MathSyntax, infix: Boolean = false): Unit = when (node) {
+public val BetterFraction: PostProcessPhase = PostProcessPhase { node ->
+ fun perform(node: MathSyntax, infix: Boolean = false): Unit = when (node) {
is NumberSyntax -> Unit
is SymbolSyntax -> Unit
is OperatorNameSyntax -> Unit
is SpecialSymbolSyntax -> Unit
- is OperandSyntax -> perform0(node.operand, infix)
+ is OperandSyntax -> perform(node.operand, infix)
is UnaryOperatorSyntax -> {
- perform0(node.prefix, infix)
- perform0(node.operand, infix)
+ perform(node.prefix, infix)
+ perform(node.operand, infix)
}
- is UnaryPlusSyntax -> perform0(node.operand, infix)
- is UnaryMinusSyntax -> perform0(node.operand, infix)
- is RadicalSyntax -> perform0(node.operand, infix)
- is ExponentSyntax -> perform0(node.operand, infix)
+ is UnaryPlusSyntax -> perform(node.operand, infix)
+ is UnaryMinusSyntax -> perform(node.operand, infix)
+ is RadicalSyntax -> perform(node.operand, infix)
+ is ExponentSyntax -> perform(node.operand, infix)
is SuperscriptSyntax -> {
- perform0(node.left, true)
- perform0(node.right, true)
+ perform(node.left, true)
+ perform(node.right, true)
}
is SubscriptSyntax -> {
- perform0(node.left, true)
- perform0(node.right, true)
+ perform(node.left, true)
+ perform(node.right, true)
}
is BinaryOperatorSyntax -> {
- perform0(node.prefix, infix)
- perform0(node.left, infix)
- perform0(node.right, infix)
+ perform(node.prefix, infix)
+ perform(node.left, infix)
+ perform(node.right, infix)
}
is BinaryPlusSyntax -> {
- perform0(node.left, infix)
- perform0(node.right, infix)
+ perform(node.left, infix)
+ perform(node.right, infix)
}
is BinaryMinusSyntax -> {
- perform0(node.left, infix)
- perform0(node.right, infix)
+ perform(node.left, infix)
+ perform(node.right, infix)
}
is FractionSyntax -> {
node.infix = infix
- perform0(node.left, infix)
- perform0(node.right, infix)
+ perform(node.left, infix)
+ perform(node.right, infix)
}
is RadicalWithIndexSyntax -> {
- perform0(node.left, true)
- perform0(node.right, true)
+ perform(node.left, true)
+ perform(node.right, true)
}
is MultiplicationSyntax -> {
- perform0(node.left, infix)
- perform0(node.right, infix)
+ perform(node.left, infix)
+ perform(node.right, infix)
}
}
- public override fun perform(node: MathSyntax): Unit = perform0(node)
+ perform(node)
}
/**
@@ -160,39 +163,37 @@ public object BetterFraction : FeaturedMathRendererWithPostProcess.PostProcessSt
* @author Iaroslav Postovalov
*/
@UnstableKMathAPI
-public object BetterExponent : FeaturedMathRendererWithPostProcess.PostProcessStage {
- private fun perform0(node: MathSyntax): Boolean {
+public val BetterExponent: PostProcessPhase = PostProcessPhase { node ->
+ fun perform(node: MathSyntax): Boolean {
return when (node) {
is NumberSyntax -> false
is SymbolSyntax -> false
is OperatorNameSyntax -> false
is SpecialSymbolSyntax -> false
- is OperandSyntax -> perform0(node.operand)
- is UnaryOperatorSyntax -> perform0(node.prefix) || perform0(node.operand)
- is UnaryPlusSyntax -> perform0(node.operand)
- is UnaryMinusSyntax -> perform0(node.operand)
+ is OperandSyntax -> perform(node.operand)
+ is UnaryOperatorSyntax -> perform(node.prefix) || perform(node.operand)
+ is UnaryPlusSyntax -> perform(node.operand)
+ is UnaryMinusSyntax -> perform(node.operand)
is RadicalSyntax -> true
is ExponentSyntax -> {
- val r = perform0(node.operand)
+ val r = perform(node.operand)
node.useOperatorForm = r
r
}
is SuperscriptSyntax -> true
is SubscriptSyntax -> true
- is BinaryOperatorSyntax -> perform0(node.prefix) || perform0(node.left) || perform0(node.right)
- is BinaryPlusSyntax -> perform0(node.left) || perform0(node.right)
- is BinaryMinusSyntax -> perform0(node.left) || perform0(node.right)
+ is BinaryOperatorSyntax -> perform(node.prefix) || perform(node.left) || perform(node.right)
+ is BinaryPlusSyntax -> perform(node.left) || perform(node.right)
+ is BinaryMinusSyntax -> perform(node.left) || perform(node.right)
is FractionSyntax -> true
is RadicalWithIndexSyntax -> true
- is MultiplicationSyntax -> perform0(node.left) || perform0(node.right)
+ is MultiplicationSyntax -> perform(node.left) || perform(node.right)
}
}
- public override fun perform(node: MathSyntax) {
- perform0(node)
- }
+ perform(node)
}
/**
@@ -203,8 +204,8 @@ public object BetterExponent : FeaturedMathRendererWithPostProcess.PostProcessSt
*/
@UnstableKMathAPI
public class SimplifyParentheses(public val precedenceFunction: (MathSyntax) -> Int) :
- FeaturedMathRendererWithPostProcess.PostProcessStage {
- public override fun perform(node: MathSyntax): Unit = when (node) {
+ PostProcessPhase {
+ override fun perform(node: MathSyntax): Unit = when (node) {
is NumberSyntax -> Unit
is SymbolSyntax -> Unit
is OperatorNameSyntax -> Unit
diff --git a/kmath-ast/src/commonTest/kotlin/space/kscience/kmath/ast/TestCompilerConsistencyWithInterpreter.kt b/kmath-ast/src/commonTest/kotlin/space/kscience/kmath/ast/TestCompilerConsistencyWithInterpreter.kt
index 6209661b3..1edb5923e 100644
--- a/kmath-ast/src/commonTest/kotlin/space/kscience/kmath/ast/TestCompilerConsistencyWithInterpreter.kt
+++ b/kmath-ast/src/commonTest/kotlin/space/kscience/kmath/ast/TestCompilerConsistencyWithInterpreter.kt
@@ -11,7 +11,6 @@ import space.kscience.kmath.expressions.Symbol.Companion.x
import space.kscience.kmath.expressions.interpret
import space.kscience.kmath.operations.DoubleField
import space.kscience.kmath.operations.IntRing
-import space.kscience.kmath.operations.bindSymbol
import space.kscience.kmath.operations.invoke
import kotlin.test.Test
import kotlin.test.assertEquals
@@ -22,7 +21,7 @@ internal class TestCompilerConsistencyWithInterpreter {
val mst = MstRing {
binaryOperationFunction("+")(
unaryOperationFunction("+")(
- (bindSymbol(x) - (2.toByte() + (scale(
+ (x - (2.toByte() + (scale(
add(number(1), number(1)),
2.0,
) + 1.toByte()))) * 3.0 - 1.toByte()
@@ -42,7 +41,7 @@ internal class TestCompilerConsistencyWithInterpreter {
fun doubleField() = runCompilerTest {
val mst = MstField {
+(3 - 2 + 2 * number(1) + 1.0) + binaryOperationFunction("+")(
- (3.0 - (bindSymbol(x) + (scale(add(number(1.0), number(1.0)), 2.0) + 1.0))) * 3 - 1.0
+ (3.0 - (x + (scale(add(number(1.0), number(1.0)), 2.0) + 1.0))) * 3 - 1.0
+ number(1),
number(1) / 2 + number(2.0) * one,
) + zero
diff --git a/kmath-ast/src/commonTest/kotlin/space/kscience/kmath/ast/TestCompilerOperations.kt b/kmath-ast/src/commonTest/kotlin/space/kscience/kmath/ast/TestCompilerOperations.kt
index 073a03f14..929d17775 100644
--- a/kmath-ast/src/commonTest/kotlin/space/kscience/kmath/ast/TestCompilerOperations.kt
+++ b/kmath-ast/src/commonTest/kotlin/space/kscience/kmath/ast/TestCompilerOperations.kt
@@ -9,7 +9,6 @@ import space.kscience.kmath.expressions.MstExtendedField
import space.kscience.kmath.expressions.Symbol.Companion.x
import space.kscience.kmath.expressions.invoke
import space.kscience.kmath.operations.DoubleField
-import space.kscience.kmath.operations.bindSymbol
import space.kscience.kmath.operations.invoke
import kotlin.test.Test
import kotlin.test.assertEquals
@@ -47,19 +46,19 @@ internal class TestCompilerOperations {
@Test
fun testSubtract() = runCompilerTest {
- val expr = MstExtendedField { bindSymbol(x) - bindSymbol(x) }.compileToExpression(DoubleField)
+ val expr = MstExtendedField { x - x }.compileToExpression(DoubleField)
assertEquals(0.0, expr(x to 2.0))
}
@Test
fun testDivide() = runCompilerTest {
- val expr = MstExtendedField { bindSymbol(x) / bindSymbol(x) }.compileToExpression(DoubleField)
+ val expr = MstExtendedField { x / x }.compileToExpression(DoubleField)
assertEquals(1.0, expr(x to 2.0))
}
@Test
fun testPower() = runCompilerTest {
- val expr = MstExtendedField { bindSymbol(x) pow 2 }.compileToExpression(DoubleField)
+ val expr = MstExtendedField { x pow 2 }.compileToExpression(DoubleField)
assertEquals(4.0, expr(x to 2.0))
}
}
diff --git a/kmath-ast/src/commonTest/kotlin/space/kscience/kmath/ast/TestCompilerVariables.kt b/kmath-ast/src/commonTest/kotlin/space/kscience/kmath/ast/TestCompilerVariables.kt
index dcc15b311..af1a2e338 100644
--- a/kmath-ast/src/commonTest/kotlin/space/kscience/kmath/ast/TestCompilerVariables.kt
+++ b/kmath-ast/src/commonTest/kotlin/space/kscience/kmath/ast/TestCompilerVariables.kt
@@ -9,7 +9,6 @@ import space.kscience.kmath.expressions.MstRing
import space.kscience.kmath.expressions.Symbol.Companion.x
import space.kscience.kmath.expressions.invoke
import space.kscience.kmath.operations.IntRing
-import space.kscience.kmath.operations.bindSymbol
import space.kscience.kmath.operations.invoke
import kotlin.test.Test
import kotlin.test.assertEquals
@@ -18,13 +17,13 @@ import kotlin.test.assertFailsWith
internal class TestCompilerVariables {
@Test
fun testVariable() = runCompilerTest {
- val expr = MstRing { bindSymbol(x) }.compileToExpression(IntRing)
+ val expr = MstRing { x }.compileToExpression(IntRing)
assertEquals(1, expr(x to 1))
}
@Test
fun testUndefinedVariableFails() = runCompilerTest {
- val expr = MstRing { bindSymbol(x) }.compileToExpression(IntRing)
+ val expr = MstRing { x }.compileToExpression(IntRing)
assertFailsWith { expr() }
}
}
diff --git a/kmath-ast/src/jsMain/kotlin/space/kscience/kmath/internal/estree/estree.kt b/kmath-ast/src/jsMain/kotlin/space/kscience/kmath/internal/estree/estree.kt
index e5254013e..b62b8c06c 100644
--- a/kmath-ast/src/jsMain/kotlin/space/kscience/kmath/internal/estree/estree.kt
+++ b/kmath-ast/src/jsMain/kotlin/space/kscience/kmath/internal/estree/estree.kt
@@ -3,6 +3,8 @@
* Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
*/
+@file:Suppress("ClassName")
+
package space.kscience.kmath.internal.estree
import kotlin.js.RegExp
diff --git a/kmath-ast/src/jsMain/kotlin/space/kscience/kmath/wasm/internal/WasmBuilder.kt b/kmath-ast/src/jsMain/kotlin/space/kscience/kmath/wasm/internal/WasmBuilder.kt
index 95ace1bad..c89ad83c4 100644
--- a/kmath-ast/src/jsMain/kotlin/space/kscience/kmath/wasm/internal/WasmBuilder.kt
+++ b/kmath-ast/src/jsMain/kotlin/space/kscience/kmath/wasm/internal/WasmBuilder.kt
@@ -27,11 +27,7 @@ internal sealed class WasmBuilder(
lateinit var ctx: BinaryenModule
open fun visitSymbolic(mst: Symbol): ExpressionRef {
- try {
- algebra.bindSymbol(mst)
- } catch (ignored: Throwable) {
- null
- }?.let { return visitNumeric(Numeric(it)) }
+ algebra.bindSymbolOrNull(mst)?.let { return visitNumeric(Numeric(it)) }
var idx = keys.indexOf(mst)
diff --git a/kmath-ast/src/jsTest/kotlin/space/kscience/kmath/ast/TestExecutionTime.kt b/kmath-ast/src/jsTest/kotlin/space/kscience/kmath/ast/TestExecutionTime.kt
index 6cb378182..d0e8128b4 100644
--- a/kmath-ast/src/jsTest/kotlin/space/kscience/kmath/ast/TestExecutionTime.kt
+++ b/kmath-ast/src/jsTest/kotlin/space/kscience/kmath/ast/TestExecutionTime.kt
@@ -7,7 +7,6 @@ package space.kscience.kmath.ast
import space.kscience.kmath.expressions.*
import space.kscience.kmath.operations.DoubleField
-import space.kscience.kmath.operations.ExtendedField
import space.kscience.kmath.operations.bindSymbol
import space.kscience.kmath.operations.invoke
import kotlin.math.sin
@@ -17,18 +16,19 @@ import kotlin.time.measureTime
import space.kscience.kmath.estree.compileToExpression as estreeCompileToExpression
import space.kscience.kmath.wasm.compileToExpression as wasmCompileToExpression
+// TODO move to benchmarks when https://github.com/Kotlin/kotlinx-benchmark/pull/38 or similar feature is merged
internal class TestExecutionTime {
private companion object {
private const val times = 1_000_000
private val x by symbol
- private val algebra: ExtendedField = DoubleField
+ private val algebra = DoubleField
private val functional = DoubleField.expressionInExtendedField {
bindSymbol(x) * const(2.0) + const(2.0) / bindSymbol(x) - const(16.0) / sin(bindSymbol(x))
}
private val node = MstExtendedField {
- bindSymbol(x) * number(2.0) + number(2.0) / bindSymbol(x) - number(16.0) / sin(bindSymbol(x))
+ x * number(2.0) + number(2.0) / x - number(16.0) / sin(x)
}
private val mst = node.toExpression(DoubleField)
@@ -43,7 +43,13 @@ internal class TestExecutionTime {
// };
private val raw = Expression { args ->
- args.getValue(x) * 2.0 + 2.0 / args.getValue(x) - 16.0 / sin(args.getValue(x))
+ val x = args[x]!!
+ x * 2.0 + 2.0 / x - 16.0 / sin(x)
+ }
+
+ private val justCalculate = { args: dynamic ->
+ val x = args[x].unsafeCast()
+ x * 2.0 + 2.0 / x - 16.0 / sin(x)
}
}
@@ -51,21 +57,56 @@ internal class TestExecutionTime {
println(name)
val rng = Random(0)
var sum = 0.0
- measureTime { repeat(times) { sum += expr(x to rng.nextDouble()) } }.also(::println)
+ measureTime {
+ repeat(times) { sum += expr(x to rng.nextDouble()) }
+ }.also(::println)
}
+ /**
+ * [Expression] created with [expressionInExtendedField].
+ */
@Test
fun functionalExpression() = invokeAndSum("functional", functional)
+ /**
+ * [Expression] created with [mstExpression].
+ */
@Test
fun mstExpression() = invokeAndSum("mst", mst)
+ /**
+ * [Expression] created with [wasmCompileToExpression].
+ */
@Test
fun wasmExpression() = invokeAndSum("wasm", wasm)
+ /**
+ * [Expression] created with [estreeCompileToExpression].
+ */
@Test
fun estreeExpression() = invokeAndSum("estree", wasm)
+ /**
+ * [Expression] implemented manually with `kotlin.math`.
+ */
@Test
fun rawExpression() = invokeAndSum("raw", raw)
+
+ /**
+ * Direct computation w/o [Expression].
+ */
+ @Test
+ fun justCalculateExpression() {
+ println("justCalculate")
+ val rng = Random(0)
+ var sum = 0.0
+ measureTime {
+ repeat(times) {
+ val arg = rng.nextDouble()
+ val o = js("{}")
+ o["x"] = arg
+ sum += justCalculate(o)
+ }
+ }.also(::println)
+ }
}
diff --git a/kmath-ast/src/jsTest/kotlin/space/kscience/kmath/ast/utils.kt b/kmath-ast/src/jsTest/kotlin/space/kscience/kmath/ast/utils.kt
index 93b7e9449..0d896c6f6 100644
--- a/kmath-ast/src/jsTest/kotlin/space/kscience/kmath/ast/utils.kt
+++ b/kmath-ast/src/jsTest/kotlin/space/kscience/kmath/ast/utils.kt
@@ -10,6 +10,8 @@ import space.kscience.kmath.expressions.MST
import space.kscience.kmath.expressions.Symbol
import space.kscience.kmath.operations.DoubleField
import space.kscience.kmath.operations.IntRing
+import kotlin.contracts.InvocationKind
+import kotlin.contracts.contract
import space.kscience.kmath.estree.compile as estreeCompile
import space.kscience.kmath.estree.compileToExpression as estreeCompileToExpression
import space.kscience.kmath.wasm.compile as wasmCompile
@@ -34,6 +36,7 @@ private object ESTreeCompilerTestContext : CompilerTestContext {
}
internal actual inline fun runCompilerTest(action: CompilerTestContext.() -> Unit) {
+ contract { callsInPlace(action, InvocationKind.AT_LEAST_ONCE) }
action(WasmCompilerTestContext)
action(ESTreeCompilerTestContext)
}
diff --git a/kmath-ast/src/jsTest/kotlin/space/kscience/kmath/wasm/TestWasmSpecific.kt b/kmath-ast/src/jsTest/kotlin/space/kscience/kmath/wasm/TestWasmSpecific.kt
index abdf865c7..8ae5fcb36 100644
--- a/kmath-ast/src/jsTest/kotlin/space/kscience/kmath/wasm/TestWasmSpecific.kt
+++ b/kmath-ast/src/jsTest/kotlin/space/kscience/kmath/wasm/TestWasmSpecific.kt
@@ -11,7 +11,6 @@ import space.kscience.kmath.expressions.invoke
import space.kscience.kmath.expressions.symbol
import space.kscience.kmath.operations.DoubleField
import space.kscience.kmath.operations.IntRing
-import space.kscience.kmath.operations.bindSymbol
import space.kscience.kmath.operations.invoke
import kotlin.test.Test
import kotlin.test.assertEquals
@@ -31,7 +30,7 @@ internal class TestWasmSpecific {
@Test
fun argsPassing() {
- val res = MstExtendedField { bindSymbol(y) + bindSymbol(x).pow(10) }.compile(
+ val res = MstExtendedField { y + x.pow(10) }.compile(
DoubleField,
x to 2.0,
y to 100000000.0,
@@ -42,7 +41,7 @@ internal class TestWasmSpecific {
@Test
fun powFunction() {
- val expr = MstExtendedField { bindSymbol(x).pow(1.0 / 6.0) }.compileToExpression(DoubleField)
+ val expr = MstExtendedField { x.pow(1.0 / 6.0) }.compileToExpression(DoubleField)
assertEquals(0.9730585187140817, expr(x to 0.8488554755054833))
}
diff --git a/kmath-ast/src/jvmMain/kotlin/space/kscience/kmath/asm/internal/codegenUtils.kt b/kmath-ast/src/jvmMain/kotlin/space/kscience/kmath/asm/internal/codegenUtils.kt
index cfac59847..06e040e93 100644
--- a/kmath-ast/src/jvmMain/kotlin/space/kscience/kmath/asm/internal/codegenUtils.kt
+++ b/kmath-ast/src/jvmMain/kotlin/space/kscience/kmath/asm/internal/codegenUtils.kt
@@ -57,13 +57,13 @@ internal fun MethodVisitor.label(): Label = Label().also(::visitLabel)
/**
* Creates a class name for [Expression] subclassed to implement [mst] provided.
*
- * This methods helps to avoid collisions of class name to prevent loading several classes with the same name. If there
+ * These methods help to avoid collisions of class name to prevent loading several classes with the same name. If there
* is a colliding class, change [collision] parameter or leave it `0` to check existing classes recursively.
*
* @author Iaroslav Postovalov
*/
internal tailrec fun buildName(mst: MST, collision: Int = 0): String {
- val name = "kscience.kmath.asm.generated.AsmCompiledExpression_${mst.hashCode()}_$collision"
+ val name = "space.kscience.kmath.asm.generated.CompiledExpression_${mst.hashCode()}_$collision"
try {
Class.forName(name)
diff --git a/kmath-ast/src/jvmTest/kotlin/space/kscience/kmath/ast/utils.kt b/kmath-ast/src/jvmTest/kotlin/space/kscience/kmath/ast/utils.kt
index d3b554efd..a7f0bb3fb 100644
--- a/kmath-ast/src/jvmTest/kotlin/space/kscience/kmath/ast/utils.kt
+++ b/kmath-ast/src/jvmTest/kotlin/space/kscience/kmath/ast/utils.kt
@@ -10,6 +10,8 @@ import space.kscience.kmath.expressions.MST
import space.kscience.kmath.expressions.Symbol
import space.kscience.kmath.operations.DoubleField
import space.kscience.kmath.operations.IntRing
+import kotlin.contracts.InvocationKind
+import kotlin.contracts.contract
import space.kscience.kmath.asm.compile as asmCompile
import space.kscience.kmath.asm.compileToExpression as asmCompileToExpression
@@ -22,4 +24,7 @@ private object AsmCompilerTestContext : CompilerTestContext {
asmCompile(algebra, arguments)
}
-internal actual inline fun runCompilerTest(action: CompilerTestContext.() -> Unit) = action(AsmCompilerTestContext)
+internal actual inline fun runCompilerTest(action: CompilerTestContext.() -> Unit) {
+ contract { callsInPlace(action, InvocationKind.EXACTLY_ONCE) }
+ action(AsmCompilerTestContext)
+}
diff --git a/kmath-commons/src/main/kotlin/space/kscience/kmath/commons/expressions/DerivativeStructureExpression.kt b/kmath-commons/src/main/kotlin/space/kscience/kmath/commons/expressions/DerivativeStructureExpression.kt
index a7ee9ff3f..5417b6156 100644
--- a/kmath-commons/src/main/kotlin/space/kscience/kmath/commons/expressions/DerivativeStructureExpression.kt
+++ b/kmath-commons/src/main/kotlin/space/kscience/kmath/commons/expressions/DerivativeStructureExpression.kt
@@ -15,7 +15,7 @@ import space.kscience.kmath.operations.NumbersAddOperations
* A field over commons-math [DerivativeStructure].
*
* @property order The derivation order.
- * @property bindings The map of bindings values. All bindings are considered free parameters
+ * @param bindings The map of bindings values. All bindings are considered free parameters
*/
@OptIn(UnstableKMathAPI::class)
public class DerivativeStructureField(
@@ -25,13 +25,13 @@ public class DerivativeStructureField(
NumbersAddOperations {
public val numberOfVariables: Int = bindings.size
- public override val zero: DerivativeStructure by lazy { DerivativeStructure(numberOfVariables, order) }
- public override val one: DerivativeStructure by lazy { DerivativeStructure(numberOfVariables, order, 1.0) }
+ override val zero: DerivativeStructure by lazy { DerivativeStructure(numberOfVariables, order) }
+ override val one: DerivativeStructure by lazy { DerivativeStructure(numberOfVariables, order, 1.0) }
- public override fun number(value: Number): DerivativeStructure = const(value.toDouble())
+ override fun number(value: Number): DerivativeStructure = const(value.toDouble())
/**
- * A class that implements both [DerivativeStructure] and a [Symbol]
+ * A class implementing both [DerivativeStructure] and [Symbol].
*/
public inner class DerivativeStructureSymbol(
size: Int,
@@ -39,10 +39,10 @@ public class DerivativeStructureField(
symbol: Symbol,
value: Double,
) : DerivativeStructure(size, order, index, value), Symbol {
- public override val identity: String = symbol.identity
- public override fun toString(): String = identity
- public override fun equals(other: Any?): Boolean = this.identity == (other as? Symbol)?.identity
- public override fun hashCode(): Int = identity.hashCode()
+ override val identity: String = symbol.identity
+ override fun toString(): String = identity
+ override fun equals(other: Any?): Boolean = this.identity == (other as? Symbol)?.identity
+ override fun hashCode(): Int = identity.hashCode()
}
/**
@@ -52,10 +52,10 @@ public class DerivativeStructureField(
key.identity to DerivativeStructureSymbol(numberOfVariables, index, key, value)
}.toMap()
- public override fun const(value: Double): DerivativeStructure = DerivativeStructure(numberOfVariables, order, value)
+ override fun const(value: Double): DerivativeStructure = DerivativeStructure(numberOfVariables, order, value)
- public override fun bindSymbolOrNull(value: String): DerivativeStructureSymbol? = variables[value]
- public override fun bindSymbol(value: String): DerivativeStructureSymbol = variables.getValue(value)
+ override fun bindSymbolOrNull(value: String): DerivativeStructureSymbol? = variables[value]
+ override fun bindSymbol(value: String): DerivativeStructureSymbol = variables.getValue(value)
public fun bindSymbolOrNull(symbol: Symbol): DerivativeStructureSymbol? = variables[symbol.identity]
public fun bindSymbol(symbol: Symbol): DerivativeStructureSymbol = variables.getValue(symbol.identity)
@@ -68,45 +68,48 @@ public class DerivativeStructureField(
public fun DerivativeStructure.derivative(vararg symbols: Symbol): Double = derivative(symbols.toList())
- public override fun DerivativeStructure.unaryMinus(): DerivativeStructure = negate()
+ override fun DerivativeStructure.unaryMinus(): DerivativeStructure = negate()
- public override fun add(a: DerivativeStructure, b: DerivativeStructure): DerivativeStructure = a.add(b)
+ override fun add(a: DerivativeStructure, b: DerivativeStructure): DerivativeStructure = a.add(b)
- public override fun scale(a: DerivativeStructure, value: Double): DerivativeStructure = a.multiply(value)
+ override fun scale(a: DerivativeStructure, value: Double): DerivativeStructure = a.multiply(value)
- public override fun multiply(a: DerivativeStructure, b: DerivativeStructure): DerivativeStructure = a.multiply(b)
- public override fun divide(a: DerivativeStructure, b: DerivativeStructure): DerivativeStructure = a.divide(b)
- public override fun sin(arg: DerivativeStructure): DerivativeStructure = arg.sin()
- public override fun cos(arg: DerivativeStructure): DerivativeStructure = arg.cos()
- public override fun tan(arg: DerivativeStructure): DerivativeStructure = arg.tan()
- public override fun asin(arg: DerivativeStructure): DerivativeStructure = arg.asin()
- public override fun acos(arg: DerivativeStructure): DerivativeStructure = arg.acos()
- public override fun atan(arg: DerivativeStructure): DerivativeStructure = arg.atan()
- public override fun sinh(arg: DerivativeStructure): DerivativeStructure = arg.sinh()
- public override fun cosh(arg: DerivativeStructure): DerivativeStructure = arg.cosh()
- public override fun tanh(arg: DerivativeStructure): DerivativeStructure = arg.tanh()
- public override fun asinh(arg: DerivativeStructure): DerivativeStructure = arg.asinh()
- public override fun acosh(arg: DerivativeStructure): DerivativeStructure = arg.acosh()
- public override fun atanh(arg: DerivativeStructure): DerivativeStructure = arg.atanh()
+ override fun multiply(a: DerivativeStructure, b: DerivativeStructure): DerivativeStructure = a.multiply(b)
+ override fun divide(a: DerivativeStructure, b: DerivativeStructure): DerivativeStructure = a.divide(b)
+ override fun sin(arg: DerivativeStructure): DerivativeStructure = arg.sin()
+ override fun cos(arg: DerivativeStructure): DerivativeStructure = arg.cos()
+ override fun tan(arg: DerivativeStructure): DerivativeStructure = arg.tan()
+ override fun asin(arg: DerivativeStructure): DerivativeStructure = arg.asin()
+ override fun acos(arg: DerivativeStructure): DerivativeStructure = arg.acos()
+ override fun atan(arg: DerivativeStructure): DerivativeStructure = arg.atan()
+ override fun sinh(arg: DerivativeStructure): DerivativeStructure = arg.sinh()
+ override fun cosh(arg: DerivativeStructure): DerivativeStructure = arg.cosh()
+ override fun tanh(arg: DerivativeStructure): DerivativeStructure = arg.tanh()
+ override fun asinh(arg: DerivativeStructure): DerivativeStructure = arg.asinh()
+ override fun acosh(arg: DerivativeStructure): DerivativeStructure = arg.acosh()
+ override fun atanh(arg: DerivativeStructure): DerivativeStructure = arg.atanh()
- public override fun power(arg: DerivativeStructure, pow: Number): DerivativeStructure = when (pow) {
+ override fun power(arg: DerivativeStructure, pow: Number): DerivativeStructure = when (pow) {
is Double -> arg.pow(pow)
is Int -> arg.pow(pow)
else -> arg.pow(pow.toDouble())
}
public fun power(arg: DerivativeStructure, pow: DerivativeStructure): DerivativeStructure = arg.pow(pow)
- public override fun exp(arg: DerivativeStructure): DerivativeStructure = arg.exp()
- public override fun ln(arg: DerivativeStructure): DerivativeStructure = arg.log()
+ override fun exp(arg: DerivativeStructure): DerivativeStructure = arg.exp()
+ override fun ln(arg: DerivativeStructure): DerivativeStructure = arg.log()
- public override operator fun DerivativeStructure.plus(b: Number): DerivativeStructure = add(b.toDouble())
- public override operator fun DerivativeStructure.minus(b: Number): DerivativeStructure = subtract(b.toDouble())
- public override operator fun Number.plus(b: DerivativeStructure): DerivativeStructure = b + this
- public override operator fun Number.minus(b: DerivativeStructure): DerivativeStructure = b - this
+ override operator fun DerivativeStructure.plus(b: Number): DerivativeStructure = add(b.toDouble())
+ override operator fun DerivativeStructure.minus(b: Number): DerivativeStructure = subtract(b.toDouble())
+ override operator fun Number.plus(b: DerivativeStructure): DerivativeStructure = b + this
+ override operator fun Number.minus(b: DerivativeStructure): DerivativeStructure = b - this
}
+/**
+ * Auto-diff processor based on Commons-math [DerivativeStructure]
+ */
public object DSProcessor : AutoDiffProcessor {
- public override fun differentiate(
+ override fun differentiate(
function: DerivativeStructureField.() -> DerivativeStructure,
): DerivativeStructureExpression = DerivativeStructureExpression(function)
}
@@ -117,13 +120,13 @@ public object DSProcessor : AutoDiffProcessor DerivativeStructure,
) : DifferentiableExpression {
- public override operator fun invoke(arguments: Map): Double =
+ override operator fun invoke(arguments: Map): Double =
DerivativeStructureField(0, arguments).function().value
/**
* Get the derivative expression with given orders
*/
- public override fun derivativeOrNull(symbols: List): Expression = Expression { arguments ->
+ override fun derivativeOrNull(symbols: List): Expression = Expression { arguments ->
with(DerivativeStructureField(symbols.size, arguments)) { function().derivative(symbols) }
}
}
diff --git a/kmath-commons/src/main/kotlin/space/kscience/kmath/commons/linear/CMMatrix.kt b/kmath-commons/src/main/kotlin/space/kscience/kmath/commons/linear/CMMatrix.kt
index c6f1cd852..c7a253ff7 100644
--- a/kmath-commons/src/main/kotlin/space/kscience/kmath/commons/linear/CMMatrix.kt
+++ b/kmath-commons/src/main/kotlin/space/kscience/kmath/commons/linear/CMMatrix.kt
@@ -15,18 +15,18 @@ import kotlin.reflect.KClass
import kotlin.reflect.cast
public class CMMatrix(public val origin: RealMatrix) : Matrix {
- public override val rowNum: Int get() = origin.rowDimension
- public override val colNum: Int get() = origin.columnDimension
+ override val rowNum: Int get() = origin.rowDimension
+ override val colNum: Int get() = origin.columnDimension
- public override operator fun get(i: Int, j: Int): Double = origin.getEntry(i, j)
+ override operator fun get(i: Int, j: Int): Double = origin.getEntry(i, j)
}
public class CMVector(public val origin: RealVector) : Point {
- public override val size: Int get() = origin.dimension
+ override val size: Int get() = origin.dimension
- public override operator fun get(index: Int): Double = origin.getEntry(index)
+ override operator fun get(index: Int): Double = origin.getEntry(index)
- public override operator fun iterator(): Iterator = origin.toArray().iterator()
+ override operator fun iterator(): Iterator = origin.toArray().iterator()
}
public fun RealVector.toPoint(): CMVector = CMVector(this)
@@ -34,7 +34,7 @@ public fun RealVector.toPoint(): CMVector = CMVector(this)
public object CMLinearSpace : LinearSpace {
override val elementAlgebra: DoubleField get() = DoubleField
- public override fun buildMatrix(
+ override fun buildMatrix(
rows: Int,
columns: Int,
initializer: DoubleField.(i: Int, j: Int) -> Double,
@@ -73,16 +73,16 @@ public object CMLinearSpace : LinearSpace {
override fun Point.minus(other: Point): CMVector =
toCM().origin.subtract(other.toCM().origin).wrap()
- public override fun Matrix.dot(other: Matrix): CMMatrix =
+ override fun Matrix.dot(other: Matrix): CMMatrix =
toCM().origin.multiply(other.toCM().origin).wrap()
- public override fun Matrix.dot(vector: Point): CMVector =
+ override fun Matrix.dot(vector: Point): CMVector =
toCM().origin.preMultiply(vector.toCM().origin).wrap()
- public override operator fun Matrix.minus(other: Matrix): CMMatrix =
+ override operator fun Matrix.minus(other: Matrix): CMMatrix =
toCM().origin.subtract(other.toCM().origin).wrap()
- public override operator fun Matrix.times(value: Double): CMMatrix =
+ override operator fun Matrix.times(value: Double): CMMatrix =
toCM().origin.scalarMultiply(value).wrap()
override fun Double.times(m: Matrix): CMMatrix =
diff --git a/kmath-commons/src/main/kotlin/space/kscience/kmath/commons/random/CMRandomGeneratorWrapper.kt b/kmath-commons/src/main/kotlin/space/kscience/kmath/commons/random/CMRandomGeneratorWrapper.kt
index 16a6967e2..6aeebb68c 100644
--- a/kmath-commons/src/main/kotlin/space/kscience/kmath/commons/random/CMRandomGeneratorWrapper.kt
+++ b/kmath-commons/src/main/kotlin/space/kscience/kmath/commons/random/CMRandomGeneratorWrapper.kt
@@ -5,35 +5,43 @@
package space.kscience.kmath.commons.random
+import kotlinx.coroutines.runBlocking
+import space.kscience.kmath.misc.PerformancePitfall
+import space.kscience.kmath.samplers.GaussianSampler
+import space.kscience.kmath.misc.toIntExact
import space.kscience.kmath.stat.RandomGenerator
+import space.kscience.kmath.stat.next
public class CMRandomGeneratorWrapper(
public val factory: (IntArray) -> RandomGenerator,
) : org.apache.commons.math3.random.RandomGenerator {
private var generator: RandomGenerator = factory(intArrayOf())
- public override fun nextBoolean(): Boolean = generator.nextBoolean()
- public override fun nextFloat(): Float = generator.nextDouble().toFloat()
+ override fun nextBoolean(): Boolean = generator.nextBoolean()
+ override fun nextFloat(): Float = generator.nextDouble().toFloat()
- public override fun setSeed(seed: Int) {
+ override fun setSeed(seed: Int) {
generator = factory(intArrayOf(seed))
}
- public override fun setSeed(seed: IntArray) {
+ override fun setSeed(seed: IntArray) {
generator = factory(seed)
}
- public override fun setSeed(seed: Long) {
- setSeed(seed.toInt())
+ override fun setSeed(seed: Long) {
+ setSeed(seed.toIntExact())
}
- public override fun nextBytes(bytes: ByteArray) {
+ override fun nextBytes(bytes: ByteArray) {
generator.fillBytes(bytes)
}
- public override fun nextInt(): Int = generator.nextInt()
- public override fun nextInt(n: Int): Int = generator.nextInt(n)
- public override fun nextGaussian(): Double = TODO()
- public override fun nextDouble(): Double = generator.nextDouble()
- public override fun nextLong(): Long = generator.nextLong()
+ override fun nextInt(): Int = generator.nextInt()
+ override fun nextInt(n: Int): Int = generator.nextInt(n)
+
+ @PerformancePitfall
+ override fun nextGaussian(): Double = runBlocking { GaussianSampler(0.0, 1.0).next(generator) }
+
+ override fun nextDouble(): Double = generator.nextDouble()
+ override fun nextLong(): Long = generator.nextLong()
}
diff --git a/kmath-commons/src/main/kotlin/space/kscience/kmath/commons/transform/Transformations.kt b/kmath-commons/src/main/kotlin/space/kscience/kmath/commons/transform/Transformations.kt
index d29491d63..6fef12138 100644
--- a/kmath-commons/src/main/kotlin/space/kscience/kmath/commons/transform/Transformations.kt
+++ b/kmath-commons/src/main/kotlin/space/kscience/kmath/commons/transform/Transformations.kt
@@ -32,7 +32,7 @@ public object Transformations {
/**
* Create a virtual buffer on top of array
*/
- private fun Array.asBuffer() = VirtualBuffer(size) {
+ private fun Array.asBuffer() = VirtualBuffer(size) {
val value = get(it)
Complex(value.real, value.imaginary)
}
diff --git a/kmath-commons/src/test/kotlin/space/kscience/kmath/commons/expressions/DerivativeStructureExpressionTest.kt b/kmath-commons/src/test/kotlin/space/kscience/kmath/commons/expressions/DerivativeStructureExpressionTest.kt
index 966675062..3c57f5467 100644
--- a/kmath-commons/src/test/kotlin/space/kscience/kmath/commons/expressions/DerivativeStructureExpressionTest.kt
+++ b/kmath-commons/src/test/kotlin/space/kscience/kmath/commons/expressions/DerivativeStructureExpressionTest.kt
@@ -16,7 +16,7 @@ internal inline fun diff(
order: Int,
vararg parameters: Pair,
block: DerivativeStructureField.() -> Unit,
-): Unit {
+) {
contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) }
DerivativeStructureField(order, mapOf(*parameters)).run(block)
}
@@ -34,7 +34,7 @@ internal class AutoDiffTest {
println(z.derivative(x))
println(z.derivative(y, x))
assertEquals(z.derivative(x, y), z.derivative(y, x))
- //check that improper order cause failure
+ // check improper order cause failure
assertFails { z.derivative(x, x, y) }
}
}
diff --git a/kmath-commons/src/test/kotlin/space/kscience/kmath/commons/optimization/OptimizeTest.kt b/kmath-commons/src/test/kotlin/space/kscience/kmath/commons/optimization/OptimizeTest.kt
index 97761cfa2..170fceceb 100644
--- a/kmath-commons/src/test/kotlin/space/kscience/kmath/commons/optimization/OptimizeTest.kt
+++ b/kmath-commons/src/test/kotlin/space/kscience/kmath/commons/optimization/OptimizeTest.kt
@@ -11,9 +11,12 @@ import space.kscience.kmath.commons.expressions.DerivativeStructureExpression
import space.kscience.kmath.distributions.NormalDistribution
import space.kscience.kmath.expressions.Symbol.Companion.x
import space.kscience.kmath.expressions.Symbol.Companion.y
+import space.kscience.kmath.expressions.chiSquaredExpression
import space.kscience.kmath.expressions.symbol
import space.kscience.kmath.optimization.*
import space.kscience.kmath.stat.RandomGenerator
+import space.kscience.kmath.structures.asBuffer
+import space.kscience.kmath.structures.map
import kotlin.math.pow
import kotlin.test.Test
@@ -49,26 +52,27 @@ internal class OptimizeTest {
val sigma = 1.0
val generator = NormalDistribution(0.0, sigma)
val chain = generator.sample(RandomGenerator.default(112667))
- val x = (1..100).map(Int::toDouble)
+ val x = (1..100).map(Int::toDouble).asBuffer()
val y = x.map {
it.pow(2) + it + 1 + chain.next()
}
- val yErr = List(x.size) { sigma }
+ val yErr = List(x.size) { sigma }.asBuffer()
- val model = DSProcessor.differentiate { x1 ->
+ val chi2 = DSProcessor.chiSquaredExpression(
+ x, y, yErr
+ ) { arg ->
val cWithDefault = bindSymbolOrNull(c) ?: one
- bindSymbol(a) * x1.pow(2) + bindSymbol(b) * x1 + cWithDefault
+ bindSymbol(a) * arg.pow(2) + bindSymbol(b) * arg + cWithDefault
}
- val chi2 = FunctionOptimization.chiSquared(x, y, yErr) { x1 ->
- val cWithDefault = bindSymbolOrNull(c) ?: one
- bindSymbol(a) * x1.pow(2) + bindSymbol(b) * x1 + cWithDefault
- }
-
- val result = chi2.minimize(a to 1.5, b to 0.9, c to 1.0)
+ val result: FunctionOptimization = chi2.optimizeWith(
+ CMOptimizer,
+ mapOf(a to 1.5, b to 0.9, c to 1.0),
+ FunctionOptimizationTarget.MINIMIZE
+ )
println(result)
- println("Chi2/dof = ${result.value / (x.size - 3)}")
+ println("Chi2/dof = ${result.resultValue / (x.size - 3)}")
}
}
diff --git a/kmath-complex/README.md b/kmath-complex/README.md
index 04431cf6c..110529b72 100644
--- a/kmath-complex/README.md
+++ b/kmath-complex/README.md
@@ -8,7 +8,7 @@ Complex and hypercomplex number systems in KMath.
## Artifact:
-The Maven coordinates of this project are `space.kscience:kmath-complex:0.3.0-dev-11`.
+The Maven coordinates of this project are `space.kscience:kmath-complex:0.3.0-dev-14`.
**Gradle:**
```gradle
@@ -18,7 +18,7 @@ repositories {
}
dependencies {
- implementation 'space.kscience:kmath-complex:0.3.0-dev-11'
+ implementation 'space.kscience:kmath-complex:0.3.0-dev-14'
}
```
**Gradle Kotlin DSL:**
@@ -29,6 +29,6 @@ repositories {
}
dependencies {
- implementation("space.kscience:kmath-complex:0.3.0-dev-11")
+ implementation("space.kscience:kmath-complex:0.3.0-dev-14")
}
```
diff --git a/kmath-complex/src/commonMain/kotlin/space/kscience/kmath/complex/Complex.kt b/kmath-complex/src/commonMain/kotlin/space/kscience/kmath/complex/Complex.kt
index a96d046c9..8b064a05f 100644
--- a/kmath-complex/src/commonMain/kotlin/space/kscience/kmath/complex/Complex.kt
+++ b/kmath-complex/src/commonMain/kotlin/space/kscience/kmath/complex/Complex.kt
@@ -54,8 +54,8 @@ private val PI_DIV_2 = Complex(PI / 2, 0)
@OptIn(UnstableKMathAPI::class)
public object ComplexField : ExtendedField, Norm, NumbersAddOperations,
ScaleOperations {
- public override val zero: Complex = 0.0.toComplex()
- public override val one: Complex = 1.0.toComplex()
+ override val zero: Complex = 0.0.toComplex()
+ override val one: Complex = 1.0.toComplex()
/**
* The imaginary unit.
@@ -68,13 +68,13 @@ public object ComplexField : ExtendedField, Norm, Num
override fun scale(a: Complex, value: Double): Complex = Complex(a.re * value, a.im * value)
- public override fun add(a: Complex, b: Complex): Complex = Complex(a.re + b.re, a.im + b.im)
-// public override fun multiply(a: Complex, k: Number): Complex = Complex(a.re * k.toDouble(), a.im * k.toDouble())
+ override fun add(a: Complex, b: Complex): Complex = Complex(a.re + b.re, a.im + b.im)
+// override fun multiply(a: Complex, k: Number): Complex = Complex(a.re * k.toDouble(), a.im * k.toDouble())
- public override fun multiply(a: Complex, b: Complex): Complex =
+ override fun multiply(a: Complex, b: Complex): Complex =
Complex(a.re * b.re - a.im * b.im, a.re * b.im + a.im * b.re)
- public override fun divide(a: Complex, b: Complex): Complex = when {
+ override fun divide(a: Complex, b: Complex): Complex = when {
abs(b.im) < abs(b.re) -> {
val wr = b.im / b.re
val wd = b.re + wr * b.im
@@ -100,31 +100,31 @@ public object ComplexField : ExtendedField, Norm, Num
override operator fun Complex.div(k: Number): Complex = Complex(re / k.toDouble(), im / k.toDouble())
- public override fun sin(arg: Complex): Complex = i * (exp(-i * arg) - exp(i * arg)) / 2.0
- public override fun cos(arg: Complex): Complex = (exp(-i * arg) + exp(i * arg)) / 2.0
+ override fun sin(arg: Complex): Complex = i * (exp(-i * arg) - exp(i * arg)) / 2.0
+ override fun cos(arg: Complex): Complex = (exp(-i * arg) + exp(i * arg)) / 2.0
- public override fun tan(arg: Complex): Complex {
+ override fun tan(arg: Complex): Complex {
val e1 = exp(-i * arg)
val e2 = exp(i * arg)
return i * (e1 - e2) / (e1 + e2)
}
- public override fun asin(arg: Complex): Complex = -i * ln(sqrt(1 - (arg * arg)) + i * arg)
- public override fun acos(arg: Complex): Complex = PI_DIV_2 + i * ln(sqrt(1 - (arg * arg)) + i * arg)
+ override fun asin(arg: Complex): Complex = -i * ln(sqrt(1 - (arg * arg)) + i * arg)
+ override fun acos(arg: Complex): Complex = PI_DIV_2 + i * ln(sqrt(1 - (arg * arg)) + i * arg)
- public override fun atan(arg: Complex): Complex {
+ override fun atan(arg: Complex): Complex {
val iArg = i * arg
return i * (ln(1 - iArg) - ln(1 + iArg)) / 2
}
- public override fun power(arg: Complex, pow: Number): Complex = if (arg.im == 0.0)
+ override fun power(arg: Complex, pow: Number): Complex = if (arg.im == 0.0)
arg.re.pow(pow.toDouble()).toComplex()
else
exp(pow * ln(arg))
- public override fun exp(arg: Complex): Complex = exp(arg.re) * (cos(arg.im) + i * sin(arg.im))
+ override fun exp(arg: Complex): Complex = exp(arg.re) * (cos(arg.im) + i * sin(arg.im))
- public override fun ln(arg: Complex): Complex = ln(arg.r) + i * atan2(arg.im, arg.re)
+ override fun ln(arg: Complex): Complex = ln(arg.r) + i * atan2(arg.im, arg.re)
/**
* Adds complex number to real one.
@@ -171,9 +171,9 @@ public object ComplexField : ExtendedField, Norm, Num
*/
public operator fun Double.times(c: Complex): Complex = Complex(c.re * this, c.im * this)
- public override fun norm(arg: Complex): Complex = sqrt(arg.conjugate * arg)
+ override fun norm(arg: Complex): Complex = sqrt(arg.conjugate * arg)
- public override fun bindSymbolOrNull(value: String): Complex? = if (value == "i") i else null
+ override fun bindSymbolOrNull(value: String): Complex? = if (value == "i") i else null
}
/**
@@ -187,16 +187,16 @@ public data class Complex(val re: Double, val im: Double) {
public constructor(re: Number, im: Number) : this(re.toDouble(), im.toDouble())
public constructor(re: Number) : this(re.toDouble(), 0.0)
- public override fun toString(): String = "($re + i * $im)"
+ override fun toString(): String = "($re + i * $im)"
public companion object : MemorySpec {
- public override val objectSize: Int
+ override val objectSize: Int
get() = 16
- public override fun MemoryReader.read(offset: Int): Complex =
+ override fun MemoryReader.read(offset: Int): Complex =
Complex(readDouble(offset), readDouble(offset + 8))
- public override fun MemoryWriter.write(offset: Int, value: Complex) {
+ override fun MemoryWriter.write(offset: Int, value: Complex) {
writeDouble(offset, value.re)
writeDouble(offset + 8, value.im)
}
diff --git a/kmath-complex/src/commonMain/kotlin/space/kscience/kmath/complex/ComplexFieldND.kt b/kmath-complex/src/commonMain/kotlin/space/kscience/kmath/complex/ComplexFieldND.kt
index 2c783eda0..1b54fc227 100644
--- a/kmath-complex/src/commonMain/kotlin/space/kscience/kmath/complex/ComplexFieldND.kt
+++ b/kmath-complex/src/commonMain/kotlin/space/kscience/kmath/complex/ComplexFieldND.kt
@@ -27,10 +27,10 @@ public class ComplexFieldND(
NumbersAddOperations>,
ExtendedField> {
- public override val zero: BufferND by lazy { produce { zero } }
- public override val one: BufferND by lazy { produce { one } }
+ override val zero: BufferND by lazy { produce { zero } }
+ override val one: BufferND by lazy { produce { one } }
- public override fun number(value: Number): BufferND {
+ override fun number(value: Number): BufferND {
val d = value.toComplex() // minimize conversions
return produce { d }
}
@@ -81,25 +81,25 @@ public class ComplexFieldND(
// return BufferedNDFieldElement(this, buffer)
// }
- public override fun power(arg: StructureND, pow: Number): BufferND = arg.map { power(it, pow) }
+ override fun power(arg: StructureND, pow: Number): BufferND = arg.map { power(it, pow) }
- public override fun exp(arg: StructureND): BufferND = arg.map { exp(it) }
+ override fun exp(arg: StructureND): BufferND = arg.map { exp(it) }
- public override fun ln(arg: StructureND): BufferND = arg.map { ln(it) }
+ override fun ln(arg: StructureND): BufferND = arg.map { ln(it) }
- public override fun sin(arg: StructureND): BufferND = arg.map { sin(it) }
- public override fun cos(arg: StructureND): BufferND = arg.map { cos(it) }
- public override fun tan(arg: StructureND): BufferND = arg.map { tan(it) }
- public override fun asin(arg: StructureND): BufferND = arg.map { asin(it) }
- public override fun acos(arg: StructureND): BufferND = arg.map { acos(it) }
- public override fun atan(arg: StructureND): BufferND = arg.map { atan(it) }
+ override fun sin(arg: StructureND): BufferND = arg.map { sin(it) }
+ override fun cos(arg: StructureND): BufferND = arg.map { cos(it) }
+ override fun tan(arg: StructureND): BufferND = arg.map { tan(it) }
+ override fun asin(arg: StructureND): BufferND = arg.map { asin(it) }
+ override fun acos(arg: StructureND): BufferND = arg.map { acos(it) }
+ override fun atan(arg: StructureND): BufferND = arg.map { atan(it) }
- public override fun sinh(arg: StructureND): BufferND = arg.map { sinh(it) }
- public override fun cosh(arg: StructureND): BufferND = arg.map { cosh(it) }
- public override fun tanh(arg: StructureND): BufferND = arg.map { tanh(it) }
- public override fun asinh(arg: StructureND): BufferND = arg.map { asinh(it) }
- public override fun acosh(arg: StructureND): BufferND = arg.map { acosh(it) }
- public override fun atanh(arg: StructureND): BufferND = arg.map { atanh(it) }
+ override fun sinh(arg: StructureND): BufferND = arg.map { sinh(it) }
+ override fun cosh(arg: StructureND): BufferND = arg.map { cosh(it) }
+ override fun tanh(arg: StructureND): BufferND = arg.map { tanh(it) }
+ override fun asinh(arg: StructureND): BufferND = arg.map { asinh(it) }
+ override fun acosh(arg: StructureND): BufferND = arg.map { acosh(it) }
+ override fun atanh(arg: StructureND): BufferND = arg.map { atanh(it) }
}
diff --git a/kmath-complex/src/commonMain/kotlin/space/kscience/kmath/complex/Quaternion.kt b/kmath-complex/src/commonMain/kotlin/space/kscience/kmath/complex/Quaternion.kt
index c59aabdcb..423cef1d1 100644
--- a/kmath-complex/src/commonMain/kotlin/space/kscience/kmath/complex/Quaternion.kt
+++ b/kmath-complex/src/commonMain/kotlin/space/kscience/kmath/complex/Quaternion.kt
@@ -63,20 +63,20 @@ public object QuaternionField : Field, Norm,
*/
public val k: Quaternion = Quaternion(0, 0, 0, 1)
- public override fun add(a: Quaternion, b: Quaternion): Quaternion =
+ override fun add(a: Quaternion, b: Quaternion): Quaternion =
Quaternion(a.w + b.w, a.x + b.x, a.y + b.y, a.z + b.z)
- public override fun scale(a: Quaternion, value: Double): Quaternion =
+ override fun scale(a: Quaternion, value: Double): Quaternion =
Quaternion(a.w * value, a.x * value, a.y * value, a.z * value)
- public override fun multiply(a: Quaternion, b: Quaternion): Quaternion = Quaternion(
+ override fun multiply(a: Quaternion, b: Quaternion): Quaternion = Quaternion(
a.w * b.w - a.x * b.x - a.y * b.y - a.z * b.z,
a.w * b.x + a.x * b.w + a.y * b.z - a.z * b.y,
a.w * b.y - a.x * b.z + a.y * b.w + a.z * b.x,
a.w * b.z + a.x * b.y - a.y * b.x + a.z * b.w,
)
- public override fun divide(a: Quaternion, b: Quaternion): Quaternion {
+ override fun divide(a: Quaternion, b: Quaternion): Quaternion {
val s = b.w * b.w + b.x * b.x + b.y * b.y + b.z * b.z
return Quaternion(
@@ -87,7 +87,7 @@ public object QuaternionField : Field, Norm,
)
}
- public override fun power(arg: Quaternion, pow: Number): Quaternion {
+ override fun power(arg: Quaternion, pow: Number): Quaternion {
if (pow is Int) return pwr(arg, pow)
if (floor(pow.toDouble()) == pow.toDouble()) return pwr(arg, pow.toInt())
return exp(pow * ln(arg))
@@ -131,7 +131,7 @@ public object QuaternionField : Field, Norm,
return Quaternion(a2 * a2 - 6 * a2 * n1 + n1 * n1, x.x * n2, x.y * n2, x.z * n2)
}
- public override fun exp(arg: Quaternion): Quaternion {
+ override fun exp(arg: Quaternion): Quaternion {
val un = arg.x * arg.x + arg.y * arg.y + arg.z * arg.z
if (un == 0.0) return exp(arg.w).toQuaternion()
val n1 = sqrt(un)
@@ -140,14 +140,14 @@ public object QuaternionField : Field, Norm,
return Quaternion(ea * cos(n1), n2 * arg.x, n2 * arg.y, n2 * arg.z)
}
- public override fun ln(arg: Quaternion): Quaternion {
+ override fun ln(arg: Quaternion): Quaternion {
val nu2 = arg.x * arg.x + arg.y * arg.y + arg.z * arg.z
if (nu2 == 0.0)
return if (arg.w > 0)
Quaternion(ln(arg.w), 0, 0, 0)
else {
- val l = ComplexField { ComplexField.ln(arg.w.toComplex()) }
+ val l = ComplexField { ln(arg.w.toComplex()) }
Quaternion(l.re, l.im, 0, 0)
}
@@ -158,21 +158,21 @@ public object QuaternionField : Field, Norm,
return Quaternion(ln(n), th * arg.x, th * arg.y, th * arg.z)
}
- public override operator fun Number.plus(b: Quaternion): Quaternion = Quaternion(toDouble() + b.w, b.x, b.y, b.z)
+ override operator fun Number.plus(b: Quaternion): Quaternion = Quaternion(toDouble() + b.w, b.x, b.y, b.z)
- public override operator fun Number.minus(b: Quaternion): Quaternion =
+ override operator fun Number.minus(b: Quaternion): Quaternion =
Quaternion(toDouble() - b.w, -b.x, -b.y, -b.z)
- public override operator fun Quaternion.plus(b: Number): Quaternion = Quaternion(w + b.toDouble(), x, y, z)
- public override operator fun Quaternion.minus(b: Number): Quaternion = Quaternion(w - b.toDouble(), x, y, z)
+ override operator fun Quaternion.plus(b: Number): Quaternion = Quaternion(w + b.toDouble(), x, y, z)
+ override operator fun Quaternion.minus(b: Number): Quaternion = Quaternion(w - b.toDouble(), x, y, z)
- public override operator fun Number.times(b: Quaternion): Quaternion =
+ override operator fun Number.times(b: Quaternion): Quaternion =
Quaternion(toDouble() * b.w, toDouble() * b.x, toDouble() * b.y, toDouble() * b.z)
- public override fun Quaternion.unaryMinus(): Quaternion = Quaternion(-w, -x, -y, -z)
- public override fun norm(arg: Quaternion): Quaternion = sqrt(arg.conjugate * arg)
+ override fun Quaternion.unaryMinus(): Quaternion = Quaternion(-w, -x, -y, -z)
+ override fun norm(arg: Quaternion): Quaternion = sqrt(arg.conjugate * arg)
- public override fun bindSymbolOrNull(value: String): Quaternion? = when (value) {
+ override fun bindSymbolOrNull(value: String): Quaternion? = when (value) {
"i" -> i
"j" -> j
"k" -> k
@@ -181,12 +181,12 @@ public object QuaternionField : Field, Norm,
override fun number(value: Number): Quaternion = value.toQuaternion()
- public override fun sinh(arg: Quaternion): Quaternion = (exp(arg) - exp(-arg)) / 2.0
- public override fun cosh(arg: Quaternion): Quaternion = (exp(arg) + exp(-arg)) / 2.0
- public override fun tanh(arg: Quaternion): Quaternion = (exp(arg) - exp(-arg)) / (exp(-arg) + exp(arg))
- public override fun asinh(arg: Quaternion): Quaternion = ln(sqrt(arg * arg + one) + arg)
- public override fun acosh(arg: Quaternion): Quaternion = ln(arg + sqrt((arg - one) * (arg + one)))
- public override fun atanh(arg: Quaternion): Quaternion = (ln(arg + one) - ln(one - arg)) / 2.0
+ override fun sinh(arg: Quaternion): Quaternion = (exp(arg) - exp(-arg)) / 2.0
+ override fun cosh(arg: Quaternion): Quaternion = (exp(arg) + exp(-arg)) / 2.0
+ override fun tanh(arg: Quaternion): Quaternion = (exp(arg) - exp(-arg)) / (exp(-arg) + exp(arg))
+ override fun asinh(arg: Quaternion): Quaternion = ln(sqrt(arg * arg + one) + arg)
+ override fun acosh(arg: Quaternion): Quaternion = ln(arg + sqrt((arg - one) * (arg + one)))
+ override fun atanh(arg: Quaternion): Quaternion = (ln(arg + one) - ln(one - arg)) / 2.0
}
/**
@@ -224,16 +224,16 @@ public data class Quaternion(
/**
* Returns a string representation of this quaternion.
*/
- public override fun toString(): String = "($w + $x * i + $y * j + $z * k)"
+ override fun toString(): String = "($w + $x * i + $y * j + $z * k)"
public companion object : MemorySpec {
- public override val objectSize: Int
+ override val objectSize: Int
get() = 32
- public override fun MemoryReader.read(offset: Int): Quaternion =
+ override fun MemoryReader.read(offset: Int): Quaternion =
Quaternion(readDouble(offset), readDouble(offset + 8), readDouble(offset + 16), readDouble(offset + 24))
- public override fun MemoryWriter.write(offset: Int, value: Quaternion) {
+ override fun MemoryWriter.write(offset: Int, value: Quaternion) {
writeDouble(offset, value.w)
writeDouble(offset + 8, value.x)
writeDouble(offset + 16, value.y)
diff --git a/kmath-core/README.md b/kmath-core/README.md
index 700eaef38..4ea493f44 100644
--- a/kmath-core/README.md
+++ b/kmath-core/README.md
@@ -10,12 +10,12 @@ The core interfaces of KMath.
objects to the expression by providing a context. Expressions can be used for a wide variety of purposes from high
performance calculations to code generation.
- [domains](src/commonMain/kotlin/space/kscience/kmath/domains) : Domains
- - [autodif](src/commonMain/kotlin/space/kscience/kmath/expressions/SimpleAutoDiff.kt) : Automatic differentiation
+ - [autodiff](src/commonMain/kotlin/space/kscience/kmath/expressions/SimpleAutoDiff.kt) : Automatic differentiation
## Artifact:
-The Maven coordinates of this project are `space.kscience:kmath-core:0.3.0-dev-11`.
+The Maven coordinates of this project are `space.kscience:kmath-core:0.3.0-dev-14`.
**Gradle:**
```gradle
@@ -25,7 +25,7 @@ repositories {
}
dependencies {
- implementation 'space.kscience:kmath-core:0.3.0-dev-11'
+ implementation 'space.kscience:kmath-core:0.3.0-dev-14'
}
```
**Gradle Kotlin DSL:**
@@ -36,6 +36,6 @@ repositories {
}
dependencies {
- implementation("space.kscience:kmath-core:0.3.0-dev-11")
+ implementation("space.kscience:kmath-core:0.3.0-dev-14")
}
```
diff --git a/kmath-core/build.gradle.kts b/kmath-core/build.gradle.kts
index 92a5f419d..564d06f49 100644
--- a/kmath-core/build.gradle.kts
+++ b/kmath-core/build.gradle.kts
@@ -19,51 +19,42 @@ readme {
feature(
id = "algebras",
- description = """
- Algebraic structures like rings, spaces and fields.
- """.trimIndent(),
- ref = "src/commonMain/kotlin/space/kscience/kmath/operations/Algebra.kt"
- )
+ ref = "src/commonMain/kotlin/space/kscience/kmath/operations/Algebra.kt",
+ ) { "Algebraic structures like rings, spaces and fields." }
feature(
id = "nd",
- description = "Many-dimensional structures and operations on them.",
- ref = "src/commonMain/kotlin/space/kscience/kmath/structures/StructureND.kt"
- )
+ ref = "src/commonMain/kotlin/space/kscience/kmath/structures/StructureND.kt",
+ ) { "Many-dimensional structures and operations on them." }
feature(
id = "linear",
- description = """
- Basic linear algebra operations (sums, products, etc.), backed by the `Space` API. Advanced linear algebra operations like matrix inversion and LU decomposition.
- """.trimIndent(),
- ref = "src/commonMain/kotlin/space/kscience/kmath/operations/Algebra.kt"
- )
+ ref = "src/commonMain/kotlin/space/kscience/kmath/operations/Algebra.kt",
+ ) { "Basic linear algebra operations (sums, products, etc.), backed by the `Space` API. Advanced linear algebra operations like matrix inversion and LU decomposition." }
feature(
id = "buffers",
- description = "One-dimensional structure",
- ref = "src/commonMain/kotlin/space/kscience/kmath/structures/Buffers.kt"
- )
+ ref = "src/commonMain/kotlin/space/kscience/kmath/structures/Buffers.kt",
+ ) { "One-dimensional structure" }
feature(
id = "expressions",
- description = """
+ ref = "src/commonMain/kotlin/space/kscience/kmath/expressions"
+ ) {
+ """
By writing a single mathematical expression once, users will be able to apply different types of
objects to the expression by providing a context. Expressions can be used for a wide variety of purposes from high
performance calculations to code generation.
- """.trimIndent(),
- ref = "src/commonMain/kotlin/space/kscience/kmath/expressions"
- )
+ """.trimIndent()
+ }
feature(
id = "domains",
- description = "Domains",
- ref = "src/commonMain/kotlin/space/kscience/kmath/domains"
- )
+ ref = "src/commonMain/kotlin/space/kscience/kmath/domains",
+ ) { "Domains" }
feature(
- id = "autodif",
- description = "Automatic differentiation",
+ id = "autodiff",
ref = "src/commonMain/kotlin/space/kscience/kmath/expressions/SimpleAutoDiff.kt"
- )
+ ) { "Automatic differentiation" }
}
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/data/XYColumnarData.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/data/XYColumnarData.kt
index 2dc82c02e..bd0e13b9d 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/data/XYColumnarData.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/data/XYColumnarData.kt
@@ -16,7 +16,7 @@ import kotlin.math.max
* The buffer of X values.
*/
@UnstableKMathAPI
-public interface XYColumnarData : ColumnarData {
+public interface XYColumnarData : ColumnarData {
/**
* The buffer of X values
*/
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/data/XYZColumnarData.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/data/XYZColumnarData.kt
index bc21b7f45..e99ae0698 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/data/XYZColumnarData.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/data/XYZColumnarData.kt
@@ -14,7 +14,7 @@ import space.kscience.kmath.structures.Buffer
* Inherits [XYColumnarData].
*/
@UnstableKMathAPI
-public interface XYZColumnarData : XYColumnarData {
+public interface XYZColumnarData : XYColumnarData {
public val z: Buffer
override fun get(symbol: Symbol): Buffer? = when (symbol) {
@@ -23,4 +23,4 @@ public interface XYZColumnarData : XYColumna
Symbol.z -> z
else -> null
}
-}
\ No newline at end of file
+}
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/Domain.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/Domain.kt
index e6e703cbf..b5a84cf6c 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/Domain.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/Domain.kt
@@ -12,7 +12,7 @@ import space.kscience.kmath.linear.Point
*
* @param T the type of element of this domain.
*/
-public interface Domain {
+public interface Domain {
/**
* Checks if the specified point is contained in this domain.
*/
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/HyperSquareDomain.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/HyperSquareDomain.kt
index f5560d935..bd5514623 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/HyperSquareDomain.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/HyperSquareDomain.kt
@@ -17,17 +17,17 @@ import space.kscience.kmath.structures.indices
*/
@UnstableKMathAPI
public class HyperSquareDomain(private val lower: Buffer, private val upper: Buffer) : DoubleDomain {
- public override val dimension: Int get() = lower.size
+ override val dimension: Int get() = lower.size
- public override operator fun contains(point: Point): Boolean = point.indices.all { i ->
+ override operator fun contains(point: Point): Boolean = point.indices.all { i ->
point[i] in lower[i]..upper[i]
}
- public override fun getLowerBound(num: Int): Double = lower[num]
+ override fun getLowerBound(num: Int): Double = lower[num]
- public override fun getUpperBound(num: Int): Double = upper[num]
+ override fun getUpperBound(num: Int): Double = upper[num]
- public override fun volume(): Double {
+ override fun volume(): Double {
var res = 1.0
for (i in 0 until dimension) {
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/UnconstrainedDomain.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/UnconstrainedDomain.kt
index 7ffc0659d..32a5fc56c 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/UnconstrainedDomain.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/UnconstrainedDomain.kt
@@ -8,12 +8,12 @@ import space.kscience.kmath.linear.Point
import space.kscience.kmath.misc.UnstableKMathAPI
@UnstableKMathAPI
-public class UnconstrainedDomain(public override val dimension: Int) : DoubleDomain {
- public override operator fun contains(point: Point): Boolean = true
+public class UnconstrainedDomain(override val dimension: Int) : DoubleDomain {
+ override operator fun contains(point: Point): Boolean = true
- public override fun getLowerBound(num: Int): Double = Double.NEGATIVE_INFINITY
+ override fun getLowerBound(num: Int): Double = Double.NEGATIVE_INFINITY
- public override fun getUpperBound(num: Int): Double = Double.POSITIVE_INFINITY
+ override fun getUpperBound(num: Int): Double = Double.POSITIVE_INFINITY
- public override fun volume(): Double = Double.POSITIVE_INFINITY
+ override fun volume(): Double = Double.POSITIVE_INFINITY
}
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/UnivariateDomain.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/UnivariateDomain.kt
index e7acada85..9020ef8cb 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/UnivariateDomain.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/UnivariateDomain.kt
@@ -10,24 +10,24 @@ import space.kscience.kmath.misc.UnstableKMathAPI
@UnstableKMathAPI
public class UnivariateDomain(public val range: ClosedFloatingPointRange) : DoubleDomain {
- public override val dimension: Int get() = 1
+ override val dimension: Int get() = 1
public operator fun contains(d: Double): Boolean = range.contains(d)
- public override operator fun contains(point: Point): Boolean {
+ override operator fun contains(point: Point): Boolean {
require(point.size == 0)
return contains(point[0])
}
- public override fun getLowerBound(num: Int): Double {
+ override fun getLowerBound(num: Int): Double {
require(num == 0)
return range.start
}
- public override fun getUpperBound(num: Int): Double {
+ override fun getUpperBound(num: Int): Double {
require(num == 0)
return range.endInclusive
}
- public override fun volume(): Double = range.endInclusive - range.start
+ override fun volume(): Double = range.endInclusive - range.start
}
diff --git a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/DifferentiableExpression.kt b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/DifferentiableExpression.kt
index 1782ff406..12b7df0ea 100644
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/DifferentiableExpression.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/DifferentiableExpression.kt
@@ -8,10 +8,9 @@ package space.kscience.kmath.expressions
import space.kscience.kmath.operations.Algebra
/**
- * Represents expression which structure can be differentiated.
+ * Represents expression, which structure can be differentiated.
*
* @param T the type this expression takes as argument and returns.
- * @param R the type of expression this expression can be differentiated to.
*/
public interface DifferentiableExpression : Expression {
/**
@@ -26,16 +25,18 @@ public interface DifferentiableExpression : Expression {
public fun DifferentiableExpression.derivative(symbols: List): Expression =
derivativeOrNull(symbols) ?: error("Derivative by symbols $symbols not provided")
-public fun DifferentiableExpression.derivative(vararg symbols: Symbol): Expression =
+public fun