A marker interface for a symbol. A symbol must have an identity with equality relation based on it. Other properties are to store additional, transient data only.

SymbolIndexer

@UnstableKMathAPI

interface SymbolIndexer

An environment to easy transform indexed variables to symbols and back. TODO requires multi-receivers to be beautiful

Functions

acos

fun <T : Any, F : ExtendedField<T>> SimpleAutoDiffField<T, F>.acos(x: AutoDiffValue<T>): AutoDiffValue<T>

acosh

fun <T : Any, F : ExtendedField<T>> SimpleAutoDiffField<T, F>.acosh(x: AutoDiffValue<T>): AutoDiffValue<T>

asin

fun <T : Any, F : ExtendedField<T>> SimpleAutoDiffField<T, F>.asin(x: AutoDiffValue<T>): AutoDiffValue<T>

asinh

fun <T : Any, F : ExtendedField<T>> SimpleAutoDiffField<T, F>.asinh(x: AutoDiffValue<T>): AutoDiffValue<T>

atan

fun <T : Any, F : ExtendedField<T>> SimpleAutoDiffField<T, F>.atan(x: AutoDiffValue<T>): AutoDiffValue<T>

atanh

fun <T : Any, F : ExtendedField<T>> SimpleAutoDiffField<T, F>.atanh(x: AutoDiffValue<T>): AutoDiffValue<T>

chiSquaredExpression

@JvmName(name = "genericChiSquaredExpression")

fun <T : Comparable<T>, I : Any, A : ExtendedField<I>, ExpressionAlgebra<T, I>> AutoDiffProcessor<T, I, A>.chiSquaredExpression(x: Buffer<T>, y: Buffer<T>, yErr: Buffer<T>, model: A.(I) -> I): DifferentiableExpression<T>

Generate a chi squared expression from given x-y-sigma data and inline model. Provides automatic differentiation.

fun <I : Any, A : ExtendedField<I>, ExpressionAlgebra<Double, I>> AutoDiffProcessor<Double, I, A>.chiSquaredExpression(x: Buffer<Double>, y: Buffer<Double>, yErr: Buffer<Double>, model: A.(I) -> I): DifferentiableExpression<Double>

const

inline fun <T : Any, F : Field<T>> SimpleAutoDiffField<T, F>.const(block: F.() -> T): AutoDiffValue<T>

cos

fun <T : Any, F : ExtendedField<T>> SimpleAutoDiffField<T, F>.cos(x: AutoDiffValue<T>): AutoDiffValue<T>

cosh

fun <T : Any, F : ExtendedField<T>> SimpleAutoDiffField<T, F>.cosh(x: AutoDiffValue<T>): AutoDiffValue<T>

derivative

fun <T> DifferentiableExpression<T>.derivative(vararg symbols: Symbol): Expression<T>

fun <T> DifferentiableExpression<T>.derivative(name: String): Expression<T>

fun <T> DifferentiableExpression<T>.derivative(symbols: List<Symbol>): Expression<T>

fun <T, R : Expression<T>> SpecialDifferentiableExpression<T, R>.derivative(vararg symbols: Symbol): R

fun <T, R : Expression<T>> SpecialDifferentiableExpression<T, R>.derivative(name: String): R

fun <T, R : Expression<T>> SpecialDifferentiableExpression<T, R>.derivative(symbols: List<Symbol>): R

exp

fun <T : Any, F : ExtendedField<T>> SimpleAutoDiffField<T, F>.exp(x: AutoDiffValue<T>): AutoDiffValue<T>

expression

inline fun DoubleField.expression(block: FunctionalExpressionExtendedField<Double, DoubleField>.() -> Expression<Double>): Expression<Double>

expressionInExtendedField

inline fun <T, A : ExtendedField<T>> A.expressionInExtendedField(block: FunctionalExpressionExtendedField<T, A>.() -> Expression<T>): Expression<T>

expressionInField

inline fun <T, A : Field<T>> A.expressionInField(block: FunctionalExpressionField<T, A>.() -> Expression<T>): Expression<T>

expressionInGroup

inline fun <T, A : Group<T>> A.expressionInGroup(block: FunctionalExpressionGroup<T, A>.() -> Expression<T>): Expression<T>

expressionInRing

inline fun <T, A : Ring<T>> A.expressionInRing(block: FunctionalExpressionRing<T, A>.() -> Expression<T>): Expression<T>

get

operator fun <T> Map<String, T>.get(symbol: Symbol): T?

Ger a value from a String-keyed map by a Symbol

operator fun <T> Map<Symbol, T>.get(string: String): T?

Get a value from a Symbol-keyed map by a String

grad

fun <T : Any> DerivationResult<T>.grad(vararg variables: Symbol): Point<T>

Computes the gradient for variables in given order.

interpret

fun <T> MST.interpret(algebra: Algebra<T>, vararg arguments: Pair<Symbol, T>): T

fun <T> MST.interpret(algebra: Algebra<T>, arguments: Map<Symbol, T>): T

Interprets the MST node with this Algebra and optional arguments

invoke

@UnstableKMathAPI

operator fun DoubleExpression.invoke(): Double

operator fun <T> Expression<T>.invoke(): T

@UnstableKMathAPI

operator fun IntExpression.invoke(): Int

@UnstableKMathAPI

operator fun LongExpression.invoke(): Long

Calls this expression without providing any arguments.

@UnstableKMathAPI

operator fun DoubleExpression.invoke(vararg arguments: Double): Double

@JvmName(name = "callByString")

operator fun <T> Expression<T>.invoke(vararg pairs: Pair<String, T>): T

@JvmName(name = "callBySymbol")

operator fun <T> Expression<T>.invoke(vararg pairs: Pair<Symbol, T>): T

@UnstableKMathAPI

operator fun IntExpression.invoke(vararg arguments: Int): Int

@UnstableKMathAPI

operator fun LongExpression.invoke(vararg arguments: Long): Long

Calls this expression from arguments.

fun <T : Any, F : ExtendedField<T>> SimpleAutoDiffField<T, F>.ln(x: AutoDiffValue<T>): AutoDiffValue<T>

pow

fun <T : Any, F : ExtendedField<T>> SimpleAutoDiffField<T, F>.pow(x: AutoDiffValue<T>, y: Double): AutoDiffValue<T>

fun <T : Any, F : ExtendedField<T>> SimpleAutoDiffField<T, F>.pow(x: AutoDiffValue<T>, y: Int): AutoDiffValue<T>

fun <T : Any, F : ExtendedField<T>> SimpleAutoDiffField<T, F>.pow(x: AutoDiffValue<T>, y: AutoDiffValue<T>): AutoDiffValue<T>

set

operator fun <T> MutableMap<String, T>.set(symbol: Symbol, value: T)

operator fun <T> MutableMap<Symbol, T>.set(string: String, value: T)

Set a value of String-keyed map by a Symbol

simpleAutoDiff

fun <T : Any, F : Field<T>> simpleAutoDiff(field: F): AutoDiffProcessor<T, AutoDiffValue<T>, SimpleAutoDiffField<T, F>>

Generate AutoDiffProcessor for SimpleAutoDiffExpression

fun <T : Any, F : Field<T>> F.simpleAutoDiff(vararg bindings: Pair<Symbol, T>, body: SimpleAutoDiffField<T, F>.() -> AutoDiffValue<T>): DerivationResult<T>

fun <T : Any, F : Field<T>> F.simpleAutoDiff(bindings: Map<Symbol, T>, body: SimpleAutoDiffField<T, F>.() -> AutoDiffValue<T>): DerivationResult<T>

Runs differentiation and establishes SimpleAutoDiffField context inside the block of code.

sin

fun <T : Any, F : ExtendedField<T>> SimpleAutoDiffField<T, F>.sin(x: AutoDiffValue<T>): AutoDiffValue<T>

sinh

fun <T : Any, F : ExtendedField<T>> SimpleAutoDiffField<T, F>.sinh(x: AutoDiffValue<T>): AutoDiffValue<T>

sqr

fun <T : Any, F : ExtendedField<T>> SimpleAutoDiffField<T, F>.sqr(x: AutoDiffValue<T>): AutoDiffValue<T>

sqrt

fun <T : Any, F : ExtendedField<T>> SimpleAutoDiffField<T, F>.sqrt(x: AutoDiffValue<T>): AutoDiffValue<T>

Symbol

fun Symbol(identity: String): Symbol

Create s Symbols with a string identity

tan

fun <T : Any, F : ExtendedField<T>> SimpleAutoDiffField<T, F>.tan(x: AutoDiffValue<T>): AutoDiffValue<T>

tanh

fun <T : Any, F : ExtendedField<T>> SimpleAutoDiffField<T, F>.tanh(x: AutoDiffValue<T>): AutoDiffValue<T>

toExpression

fun <T : Any> MST.toExpression(algebra: Algebra<T>): Expression<T>

Interpret this MST as expression.

withSymbols

@UnstableKMathAPI

inline fun <R> withSymbols(vararg symbols: Symbol, block: SymbolIndexer.() -> R): R

Execute the block with symbol indexer based on given symbol order

@UnstableKMathAPI

inline fun <R> withSymbols(symbols: Collection<Symbol>, block: SymbolIndexer.() -> R): R

Properties

binding

val <T, E> ExpressionAlgebra<T, E>.binding: ReadOnlyProperty<Any?, E>

Bind a symbol by name inside the ExpressionAlgebra

symbol

val symbol: ReadOnlyProperty<Any?, Symbol>

A delegate to create a symbol with a string identity in this scope