From 37ad48e820cde271ba93d1249b84b0abfd033f21 Mon Sep 17 00:00:00 2001
From: Gleb Minaev <43728100+lounres@users.noreply.github.com>
Date: Mon, 13 Jun 2022 02:06:15 +0300
Subject: [PATCH] Sift # 3. Filtered last sift and usages of [ListPolynomial]s.
---
.../kmath/functions/LabeledPolynomial.kt | 539 ------------------
.../functions/LabeledRationalFunction.kt | 139 -----
.../kmath/functions/ListPolynomial.kt | 80 ++-
.../kmath/functions/ListRationalFunction.kt | 158 +++--
.../kmath/functions/NumberedPolynomial.kt | 389 -------------
.../functions/NumberedRationalFunction.kt | 188 ------
.../kscience/kmath/functions/Polynomial.kt | 152 ++++-
.../kmath/functions/RationalFunction.kt | 511 ++++++++++++-----
.../kmath/functions/labeledConstructors.kt | 203 -------
.../kmath/functions/labeledPolynomialUtil.kt | 495 ----------------
.../functions/labeledRationalFunctionUtil.kt | 33 --
.../kmath/functions/listConstructors.kt | 61 +-
.../kmath/functions/listPolynomialUtil.kt | 233 --------
.../kscience/kmath/functions/listUtil.kt | 268 +++++++++
...alFunctionUtil.kt => listUtilOptimized.kt} | 129 +++--
.../space/kscience/kmath/functions/misc.kt | 13 +
.../kmath/functions/numberedConstructors.kt | 195 -------
.../kmath/functions/numberedPolynomialUtil.kt | 528 -----------------
.../functions/numberedRationalFunctionUtil.kt | 33 --
.../kmath/functions/ListPolynomialTest.kt | 32 +-
.../kmath/functions/ListPolynomialUtilTest.kt | 2 +
.../kscience/kmath/test/misc/IntModulo.kt | 138 +++++
.../kscience/kmath/test/misc/Rational.kt | 135 +++++
.../space/kscience/kmath/test/misc/misc.kt | 29 +
24 files changed, 1378 insertions(+), 3305 deletions(-)
delete mode 100644 kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/LabeledPolynomial.kt
delete mode 100644 kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/LabeledRationalFunction.kt
delete mode 100644 kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/NumberedPolynomial.kt
delete mode 100644 kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/NumberedRationalFunction.kt
delete mode 100644 kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/labeledConstructors.kt
delete mode 100644 kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/labeledPolynomialUtil.kt
delete mode 100644 kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/labeledRationalFunctionUtil.kt
delete mode 100644 kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/listPolynomialUtil.kt
create mode 100644 kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/listUtil.kt
rename kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/{listRationalFunctionUtil.kt => listUtilOptimized.kt} (72%)
create mode 100644 kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/misc.kt
delete mode 100644 kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/numberedConstructors.kt
delete mode 100644 kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/numberedPolynomialUtil.kt
delete mode 100644 kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/numberedRationalFunctionUtil.kt
create mode 100644 kmath-functions/src/commonTest/kotlin/space/kscience/kmath/test/misc/IntModulo.kt
create mode 100644 kmath-functions/src/commonTest/kotlin/space/kscience/kmath/test/misc/Rational.kt
create mode 100644 kmath-functions/src/commonTest/kotlin/space/kscience/kmath/test/misc/misc.kt
diff --git a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/LabeledPolynomial.kt b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/LabeledPolynomial.kt
deleted file mode 100644
index b904f7331..000000000
--- a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/LabeledPolynomial.kt
+++ /dev/null
@@ -1,539 +0,0 @@
-/*
- * Copyright 2018-2021 KMath contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package space.kscience.kmath.functions
-
-import space.kscience.kmath.expressions.Symbol
-import space.kscience.kmath.operations.Ring
-import space.kscience.kmath.operations.ScaleOperations
-import kotlin.math.max
-
-
-/**
- * Represents multivariate polynomials with labeled variables.
- *
- * @param C Ring in which the polynomial is considered.
- */
-public data class LabeledPolynomial<C>
-internal constructor(
- /**
- * Map that collects coefficients of the polynomial. Every non-zero monomial
- * `a x_1^{d_1} ... x_n^{d_n}` is represented as pair "key-value" in the map, where value is coefficients `a` and
- * key is map that associates variables in the monomial with multiplicity of them occurring in the monomial.
- * For example polynomial
- * ```
- * 5 a^2 c^3 - 6 b + 0 b c
- * ```
- * has coefficients represented as
- * ```
- * mapOf(
- * mapOf(
- * a to 2,
- * c to 3
- * ) to 5,
- * mapOf(
- * b to 1
- * ) to (-6)
- * )
- * ```
- * where `a`, `b` and `c` are corresponding [Symbol] objects.
- */
- public val coefficients: Map<Map<Symbol, UInt>, C>
-) : Polynomial<C> {
- override fun toString(): String = "LabeledPolynomial$coefficients"
-}
-
-/**
- * Space of polynomials.
- *
- * @param C the type of operated polynomials.
- * @param A the intersection of [Ring] of [C] and [ScaleOperations] of [C].
- * @param ring the [A] instance.
- */
-public class LabeledPolynomialSpace<C, A : Ring<C>>(
- public override val ring: A,
-) : MultivariatePolynomialSpace<C, Symbol, LabeledPolynomial<C>>, PolynomialSpaceOverRing<C, LabeledPolynomial<C>, A> {
- public override operator fun Symbol.plus(other: Int): LabeledPolynomial<C> =
- if (other == 0) LabeledPolynomial<C>(mapOf(
- mapOf(this@plus to 1U) to constantOne,
- ))
- else LabeledPolynomial<C>(mapOf(
- mapOf(this@plus to 1U) to constantOne,
- emptyMap<Symbol, UInt>() to constantOne * other,
- ))
- public override operator fun Symbol.minus(other: Int): LabeledPolynomial<C> =
- if (other == 0) LabeledPolynomial<C>(mapOf(
- mapOf(this@minus to 1U) to -constantOne,
- ))
- else LabeledPolynomial<C>(mapOf(
- mapOf(this@minus to 1U) to -constantOne,
- emptyMap<Symbol, UInt>() to constantOne * other,
- ))
- public override operator fun Symbol.times(other: Int): LabeledPolynomial<C> =
- if (other == 0) zero
- else LabeledPolynomial<C>(mapOf(
- mapOf(this to 1U) to constantOne * other,
- ))
-
- public override operator fun Int.plus(other: Symbol): LabeledPolynomial<C> =
- if (this == 0) LabeledPolynomial<C>(mapOf(
- mapOf(other to 1U) to constantOne,
- ))
- else LabeledPolynomial<C>(mapOf(
- mapOf(other to 1U) to constantOne,
- emptyMap<Symbol, UInt>() to constantOne * this@plus,
- ))
- public override operator fun Int.minus(other: Symbol): LabeledPolynomial<C> =
- if (this == 0) LabeledPolynomial<C>(mapOf(
- mapOf(other to 1U) to -constantOne,
- ))
- else LabeledPolynomial<C>(mapOf(
- mapOf(other to 1U) to -constantOne,
- emptyMap<Symbol, UInt>() to constantOne * this@minus,
- ))
- public override operator fun Int.times(other: Symbol): LabeledPolynomial<C> =
- if (this == 0) zero
- else LabeledPolynomial<C>(mapOf(
- mapOf(other to 1U) to constantOne * this@times,
- ))
-
- /**
- * Returns sum of the polynomial and the integer represented as polynomial.
- *
- * The operation is equivalent to adding [other] copies of unit polynomial to [this].
- */
- public override operator fun LabeledPolynomial<C>.plus(other: Int): LabeledPolynomial<C> =
- if (other == 0) this
- else with(coefficients) {
- if (isEmpty()) LabeledPolynomial<C>(mapOf(emptyMap<Symbol, UInt>() to other.asConstant()))
- else LabeledPolynomial<C>(
- toMutableMap()
- .apply {
- val degs = emptyMap<Symbol, UInt>()
-
- this[degs] = getOrElse(degs) { constantZero } + other
- }
- )
- }
- /**
- * Returns difference between the polynomial and the integer represented as polynomial.
- *
- * The operation is equivalent to subtraction [other] copies of unit polynomial from [this].
- */
- public override operator fun LabeledPolynomial<C>.minus(other: Int): LabeledPolynomial<C> =
- if (other == 0) this
- else with(coefficients) {
- if (isEmpty()) LabeledPolynomial<C>(mapOf(emptyMap<Symbol, UInt>() to (-other).asConstant()))
- else LabeledPolynomial<C>(
- toMutableMap()
- .apply {
- val degs = emptyMap<Symbol, UInt>()
-
- this[degs] = getOrElse(degs) { constantZero } - other
- }
- )
- }
- /**
- * Returns product of the polynomial and the integer represented as polynomial.
- *
- * The operation is equivalent to sum of [other] copies of [this].
- */
- public override operator fun LabeledPolynomial<C>.times(other: Int): LabeledPolynomial<C> =
- if (other == 0) zero
- else LabeledPolynomial(
- coefficients
- .toMutableMap()
- .apply {
- for (degs in keys) this[degs] = this[degs]!! * other
- }
- )
-
- /**
- * Returns sum of the integer represented as polynomial and the polynomial.
- *
- * The operation is equivalent to adding [this] copies of unit polynomial to [other].
- */
- public override operator fun Int.plus(other: LabeledPolynomial<C>): LabeledPolynomial<C> =
- if (this == 0) other
- else with(other.coefficients) {
- if (isEmpty()) LabeledPolynomial<C>(mapOf(emptyMap<Symbol, UInt>() to this@plus.asConstant()))
- else LabeledPolynomial<C>(
- toMutableMap()
- .apply {
- val degs = emptyMap<Symbol, UInt>()
-
- this[degs] = this@plus + getOrElse(degs) { constantZero }
- }
- )
- }
- /**
- * Returns difference between the integer represented as polynomial and the polynomial.
- *
- * The operation is equivalent to subtraction [this] copies of unit polynomial from [other].
- */
- public override operator fun Int.minus(other: LabeledPolynomial<C>): LabeledPolynomial<C> =
- if (this == 0) other
- else with(other.coefficients) {
- if (isEmpty()) LabeledPolynomial<C>(mapOf(emptyMap<Symbol, UInt>() to this@minus.asConstant()))
- else LabeledPolynomial<C>(
- toMutableMap()
- .apply {
- val degs = emptyMap<Symbol, UInt>()
-
- this[degs] = this@minus - getOrElse(degs) { constantZero }
- }
- )
- }
- /**
- * Returns product of the integer represented as polynomial and the polynomial.
- *
- * The operation is equivalent to sum of [this] copies of [other].
- */
- public override operator fun Int.times(other: LabeledPolynomial<C>): LabeledPolynomial<C> =
- if (this == 0) zero
- else LabeledPolynomial(
- other.coefficients
- .toMutableMap()
- .apply {
- for (degs in keys) this[degs] = this@times * this[degs]!!
- }
- )
-
- /**
- * Converts the integer [value] to polynomial.
- */
- public override fun number(value: Int): LabeledPolynomial<C> = number(constantNumber(value))
-
- public override operator fun C.plus(other: Symbol): LabeledPolynomial<C> =
- LabeledPolynomial<C>(mapOf(
- mapOf(other to 1U) to constantOne,
- emptyMap<Symbol, UInt>() to this@plus,
- ))
- public override operator fun C.minus(other: Symbol): LabeledPolynomial<C> =
- LabeledPolynomial<C>(mapOf(
- mapOf(other to 1U) to -constantOne,
- emptyMap<Symbol, UInt>() to this@minus,
- ))
- public override operator fun C.times(other: Symbol): LabeledPolynomial<C> =
- LabeledPolynomial<C>(mapOf(
- mapOf(other to 1U) to this@times,
- ))
-
- public override operator fun Symbol.plus(other: C): LabeledPolynomial<C> =
- LabeledPolynomial<C>(mapOf(
- mapOf(this@plus to 1U) to constantOne,
- emptyMap<Symbol, UInt>() to other,
- ))
- public override operator fun Symbol.minus(other: C): LabeledPolynomial<C> =
- LabeledPolynomial<C>(mapOf(
- mapOf(this@minus to 1U) to -constantOne,
- emptyMap<Symbol, UInt>() to other,
- ))
- public override operator fun Symbol.times(other: C): LabeledPolynomial<C> =
- LabeledPolynomial<C>(mapOf(
- mapOf(this@times to 1U) to other,
- ))
-
- /**
- * Returns sum of the constant represented as polynomial and the polynomial.
- */
- override operator fun C.plus(other: LabeledPolynomial<C>): LabeledPolynomial<C> =
- with(other.coefficients) {
- if (isEmpty()) LabeledPolynomial<C>(mapOf(emptyMap<Symbol, UInt>() to this@plus))
- else LabeledPolynomial<C>(
- toMutableMap()
- .apply {
- val degs = emptyMap<Symbol, UInt>()
-
- this[degs] = this@plus + getOrElse(degs) { constantZero }
- }
- )
- }
- /**
- * Returns difference between the constant represented as polynomial and the polynomial.
- */
- override operator fun C.minus(other: LabeledPolynomial<C>): LabeledPolynomial<C> =
- with(other.coefficients) {
- if (isEmpty()) LabeledPolynomial<C>(mapOf(emptyMap<Symbol, UInt>() to this@minus))
- else LabeledPolynomial<C>(
- toMutableMap()
- .apply {
- forEach { (degs, c) -> if(degs.isNotEmpty()) this[degs] = -c }
-
- val degs = emptyMap<Symbol, UInt>()
-
- this[degs] = this@minus - getOrElse(degs) { constantZero }
- }
- )
- }
- /**
- * Returns product of the constant represented as polynomial and the polynomial.
- */
- override operator fun C.times(other: LabeledPolynomial<C>): LabeledPolynomial<C> =
- LabeledPolynomial<C>(
- other.coefficients
- .toMutableMap()
- .apply {
- for (degs in keys) this[degs] = this@times * this[degs]!!
- }
- )
-
- /**
- * Returns sum of the constant represented as polynomial and the polynomial.
- */
- override operator fun LabeledPolynomial<C>.plus(other: C): LabeledPolynomial<C> =
- with(coefficients) {
- if (isEmpty()) LabeledPolynomial<C>(mapOf(emptyMap<Symbol, UInt>() to other))
- else LabeledPolynomial<C>(
- toMutableMap()
- .apply {
- val degs = emptyMap<Symbol, UInt>()
-
- this[degs] = getOrElse(degs) { constantZero } + other
- }
- )
- }
- /**
- * Returns difference between the constant represented as polynomial and the polynomial.
- */
- override operator fun LabeledPolynomial<C>.minus(other: C): LabeledPolynomial<C> =
- with(coefficients) {
- if (isEmpty()) LabeledPolynomial<C>(mapOf(emptyMap<Symbol, UInt>() to other))
- else LabeledPolynomial<C>(
- toMutableMap()
- .apply {
- forEach { (degs, c) -> if(degs.isNotEmpty()) this[degs] = -c }
-
- val degs = emptyMap<Symbol, UInt>()
-
- this[degs] = getOrElse(degs) { constantZero } - other
- }
- )
- }
- /**
- * Returns product of the constant represented as polynomial and the polynomial.
- */
- override operator fun LabeledPolynomial<C>.times(other: C): LabeledPolynomial<C> =
- LabeledPolynomial<C>(
- coefficients
- .toMutableMap()
- .apply {
- for (degs in keys) this[degs] = this[degs]!! * other
- }
- )
-
- /**
- * Converts the constant [value] to polynomial.
- */
- public override fun number(value: C): LabeledPolynomial<C> =
- LabeledPolynomial(mapOf(emptyMap<Symbol, UInt>() to value))
-
- public override operator fun Symbol.unaryPlus(): LabeledPolynomial<C> =
- LabeledPolynomial<C>(mapOf(
- mapOf(this to 1U) to constantOne,
- ))
- public override operator fun Symbol.unaryMinus(): LabeledPolynomial<C> =
- LabeledPolynomial<C>(mapOf(
- mapOf(this to 1U) to -constantOne,
- ))
- public override operator fun Symbol.plus(other: Symbol): LabeledPolynomial<C> =
- if (this == other) LabeledPolynomial<C>(mapOf(
- mapOf(this to 1U) to constantOne * 2
- ))
- else LabeledPolynomial<C>(mapOf(
- mapOf(this to 1U) to constantOne,
- mapOf(other to 1U) to constantOne,
- ))
- public override operator fun Symbol.minus(other: Symbol): LabeledPolynomial<C> =
- if (this == other) zero
- else LabeledPolynomial<C>(mapOf(
- mapOf(this to 1U) to constantOne,
- mapOf(other to 1U) to -constantOne,
- ))
- public override operator fun Symbol.times(other: Symbol): LabeledPolynomial<C> =
- if (this == other) LabeledPolynomial<C>(mapOf(
- mapOf(this to 2U) to constantOne
- ))
- else LabeledPolynomial<C>(mapOf(
- mapOf(this to 1U, other to 1U) to constantOne,
- ))
-
- public override operator fun Symbol.plus(other: LabeledPolynomial<C>): LabeledPolynomial<C> =
- with(other.coefficients) {
- if (isEmpty()) LabeledPolynomial<C>(mapOf(mapOf(this@plus to 1u) to constantOne))
- else LabeledPolynomial<C>(
- toMutableMap()
- .apply {
- val degs = mapOf(this@plus to 1U)
-
- this[degs] = constantOne + getOrElse(degs) { constantZero }
- }
- )
- }
- public override operator fun Symbol.minus(other: LabeledPolynomial<C>): LabeledPolynomial<C> =
- with(other.coefficients) {
- if (isEmpty()) LabeledPolynomial<C>(mapOf(mapOf(this@minus to 1u) to constantOne))
- else LabeledPolynomial<C>(
- toMutableMap()
- .apply {
- forEach { (degs, c) -> if(degs.isNotEmpty()) this[degs] = -c }
-
- val degs = mapOf(this@minus to 1U)
-
- this[degs] = constantOne - getOrElse(degs) { constantZero }
- }
- )
- }
- public override operator fun Symbol.times(other: LabeledPolynomial<C>): LabeledPolynomial<C> =
- LabeledPolynomial<C>(
- other.coefficients
- .mapKeys { (degs, _) -> degs.toMutableMap().also{ it[this] = if (this in it) it[this]!! + 1U else 1U } }
- )
-
- public override operator fun LabeledPolynomial<C>.plus(other: Symbol): LabeledPolynomial<C> =
- with(coefficients) {
- if (isEmpty()) LabeledPolynomial<C>(mapOf(mapOf(other to 1u) to constantOne))
- else LabeledPolynomial<C>(
- toMutableMap()
- .apply {
- val degs = mapOf(other to 1U)
-
- this[degs] = constantOne + getOrElse(degs) { constantZero }
- }
- )
- }
- public override operator fun LabeledPolynomial<C>.minus(other: Symbol): LabeledPolynomial<C> =
- with(coefficients) {
- if (isEmpty()) LabeledPolynomial<C>(mapOf(mapOf(other to 1u) to constantOne))
- else LabeledPolynomial<C>(
- toMutableMap()
- .apply {
- val degs = mapOf(other to 1U)
-
- this[degs] = constantOne - getOrElse(degs) { constantZero }
- }
- )
- }
- public override operator fun LabeledPolynomial<C>.times(other: Symbol): LabeledPolynomial<C> =
- LabeledPolynomial<C>(
- coefficients
- .mapKeys { (degs, _) -> degs.toMutableMap().also{ it[other] = if (other in it) it[other]!! + 1U else 1U } }
- )
-
- /**
- * Returns negation of the polynomial.
- */
- override fun LabeledPolynomial<C>.unaryMinus(): LabeledPolynomial<C> =
- LabeledPolynomial<C>(
- coefficients.mapValues { -it.value }
- )
- /**
- * Returns sum of the polynomials.
- */
- override operator fun LabeledPolynomial<C>.plus(other: LabeledPolynomial<C>): LabeledPolynomial<C> =
- LabeledPolynomial<C>(
- buildMap(coefficients.size + other.coefficients.size) {
- other.coefficients.mapValuesTo(this) { it.value }
- other.coefficients.mapValuesTo(this) { (key, value) -> if (key in this) this[key]!! + value else value }
- }
- )
- /**
- * Returns difference of the polynomials.
- */
- override operator fun LabeledPolynomial<C>.minus(other: LabeledPolynomial<C>): LabeledPolynomial<C> =
- LabeledPolynomial<C>(
- buildMap(coefficients.size + other.coefficients.size) {
- other.coefficients.mapValuesTo(this) { it.value }
- other.coefficients.mapValuesTo(this) { (key, value) -> if (key in this) this[key]!! - value else -value }
- }
- )
- /**
- * Returns product of the polynomials.
- */
- override operator fun LabeledPolynomial<C>.times(other: LabeledPolynomial<C>): LabeledPolynomial<C> =
- LabeledPolynomial<C>(
- buildMap(coefficients.size * other.coefficients.size) {
- for ((degs1, c1) in coefficients) for ((degs2, c2) in other.coefficients) {
- val degs = degs1.toMutableMap()
- degs2.mapValuesTo(degs) { (variable, deg) -> degs.getOrElse(variable) { 0u } + deg }
- val c = c1 * c2
- this[degs] = if (degs in this) this[degs]!! + c else c
- }
- }
- )
-
- /**
- * Instance of zero polynomial (zero of the polynomial ring).
- */
- override val zero: LabeledPolynomial<C> = LabeledPolynomial<C>(mapOf(emptyMap<Symbol, UInt>() to constantZero))
- /**
- * Instance of unit polynomial (unit of the polynomial ring).
- */
- override val one: LabeledPolynomial<C> = LabeledPolynomial<C>(mapOf(emptyMap<Symbol, UInt>() to constantOne))
-
- /**
- * Degree of the polynomial, [see also](https://en.wikipedia.org/wiki/Degree_of_a_polynomial). If the polynomial is
- * zero, degree is -1.
- */
- override val LabeledPolynomial<C>.degree: Int
- get() = coefficients.entries.maxOfOrNull { (degs, c) -> degs.values.sum().toInt() } ?: -1
- /**
- * Map that associates variables (that appear in the polynomial in positive exponents) with their most exponents
- * in which they are appeared in the polynomial.
- *
- * As consequence all values in the map are positive integers. Also, if the polynomial is constant, the map is empty.
- * And keys of the map is the same as in [variables].
- */
- public override val LabeledPolynomial<C>.degrees: Map<Symbol, UInt>
- get() =
- buildMap {
- coefficients.entries.forEach { (degs, _) ->
- degs.mapValuesTo(this) { (variable, deg) ->
- max(getOrElse(variable) { 0u }, deg)
- }
- }
- }
- /**
- * Counts degree of the polynomial by the specified [variable].
- */
- public override fun LabeledPolynomial<C>.degreeBy(variable: Symbol): UInt =
- coefficients.entries.maxOfOrNull { (degs, _) -> degs.getOrElse(variable) { 0u } } ?: 0u
- /**
- * Counts degree of the polynomial by the specified [variables].
- */
- public override fun LabeledPolynomial<C>.degreeBy(variables: Collection<Symbol>): UInt =
- coefficients.entries.maxOfOrNull { (degs, _) -> degs.filterKeys { it in variables }.values.sum() } ?: 0u
- /**
- * Set of all variables that appear in the polynomial in positive exponents.
- */
- public override val LabeledPolynomial<C>.variables: Set<Symbol>
- get() =
- buildSet {
- coefficients.entries.forEach { (degs, _) -> addAll(degs.keys) }
- }
- /**
- * Count of all variables that appear in the polynomial in positive exponents.
- */
- public override val LabeledPolynomial<C>.countOfVariables: Int get() = variables.size
-
-// @Suppress("NOTHING_TO_INLINE")
-// public inline fun LabeledPolynomial<C>.substitute(argument: Map<Symbol, C>): LabeledPolynomial<C> = this.substitute(ring, argument)
-// @Suppress("NOTHING_TO_INLINE")
-// @JvmName("substitutePolynomial")
-// public inline fun LabeledPolynomial<C>.substitute(argument: Map<Symbol, LabeledPolynomial<C>>): LabeledPolynomial<C> = this.substitute(ring, argument)
-//
-// @Suppress("NOTHING_TO_INLINE")
-// public inline fun LabeledPolynomial<C>.asFunction(): (Map<Symbol, C>) -> LabeledPolynomial<C> = { this.substitute(ring, it) }
-// @Suppress("NOTHING_TO_INLINE")
-// public inline fun LabeledPolynomial<C>.asFunctionOnConstants(): (Map<Symbol, C>) -> LabeledPolynomial<C> = { this.substitute(ring, it) }
-// @Suppress("NOTHING_TO_INLINE")
-// public inline fun LabeledPolynomial<C>.asFunctionOnPolynomials(): (Map<Symbol, LabeledPolynomial<C>>) -> LabeledPolynomial<C> = { this.substitute(ring, it) }
-//
-// @Suppress("NOTHING_TO_INLINE")
-// public inline operator fun LabeledPolynomial<C>.invoke(argument: Map<Symbol, C>): LabeledPolynomial<C> = this.substitute(ring, argument)
-// @Suppress("NOTHING_TO_INLINE")
-// @JvmName("invokePolynomial")
-// public inline operator fun LabeledPolynomial<C>.invoke(argument: Map<Symbol, LabeledPolynomial<C>>): LabeledPolynomial<C> = this.substitute(ring, argument)
-}
\ No newline at end of file
diff --git a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/LabeledRationalFunction.kt b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/LabeledRationalFunction.kt
deleted file mode 100644
index 76c6874f5..000000000
--- a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/LabeledRationalFunction.kt
+++ /dev/null
@@ -1,139 +0,0 @@
-/*
- * Copyright 2018-2021 KMath contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package space.kscience.kmath.functions
-
-import space.kscience.kmath.expressions.Symbol
-import space.kscience.kmath.operations.Ring
-import space.kscience.kmath.operations.invoke
-
-
-public class LabeledRationalFunction<C>(
- public override val numerator: LabeledPolynomial<C>,
- public override val denominator: LabeledPolynomial<C>
-) : RationalFunction<C, LabeledPolynomial<C>> {
- override fun toString(): String = "LabeledRationalFunction${numerator.coefficients}/${denominator.coefficients}"
-}
-
-public class LabeledRationalFunctionSpace<C, A: Ring<C>>(
- public val ring: A,
-) :
- MultivariateRationalFunctionalSpaceOverMultivariatePolynomialSpace<
- C,
- Symbol,
- LabeledPolynomial<C>,
- LabeledRationalFunction<C>,
- LabeledPolynomialSpace<C, A>,
- >,
- MultivariatePolynomialSpaceOfFractions<
- C,
- Symbol,
- LabeledPolynomial<C>,
- LabeledRationalFunction<C>,
- >() {
-
- override val polynomialRing : LabeledPolynomialSpace<C, A> = LabeledPolynomialSpace(ring)
- override fun constructRationalFunction(
- numerator: LabeledPolynomial<C>,
- denominator: LabeledPolynomial<C>
- ): LabeledRationalFunction<C> =
- LabeledRationalFunction<C>(numerator, denominator)
-
- /**
- * Instance of zero rational function (zero of the rational functions ring).
- */
- public override val zero: LabeledRationalFunction<C> = LabeledRationalFunction<C>(polynomialZero, polynomialOne)
- /**
- * Instance of unit polynomial (unit of the rational functions ring).
- */
- public override val one: LabeledRationalFunction<C> = LabeledRationalFunction<C>(polynomialOne, polynomialOne)
-
- // TODO: Разобрать
-
-// operator fun invoke(arg: Map<Symbol, C>): LabeledRationalFunction<C> =
-// LabeledRationalFunction(
-// numerator(arg),
-// denominator(arg)
-// )
-//
-// @JvmName("invokeLabeledPolynomial")
-// operator fun invoke(arg: Map<Symbol, LabeledPolynomial<C>>): LabeledRationalFunction<C> =
-// LabeledRationalFunction(
-// numerator(arg),
-// denominator(arg)
-// )
-//
-// @JvmName("invokeLabeledRationalFunction")
-// operator fun invoke(arg: Map<Symbol, LabeledRationalFunction<C>>): LabeledRationalFunction<C> {
-// var num = numerator invokeRFTakeNumerator arg
-// var den = denominator invokeRFTakeNumerator arg
-// for (variable in variables) if (variable in arg) {
-// val degreeDif = degrees[variable]!!
-// if (degreeDif > 0)
-// den = multiplyByPower(den, arg[variable]!!.denominator, degreeDif)
-// else
-// num = multiplyByPower(num, arg[variable]!!.denominator, -degreeDif)
-// }
-// return LabeledRationalFunction(num, den)
-// }
-//
-// override fun toString(): String = toString(emptyMap())
-//
-// fun toString(names: Map<Symbol, String> = emptyMap()): String =
-// when (true) {
-// numerator.isZero() -> "0"
-// denominator.isOne() -> numerator.toString(names)
-// else -> "${numerator.toStringWithBrackets(names)}/${denominator.toStringWithBrackets(names)}"
-// }
-//
-// fun toString(namer: (Symbol) -> String): String =
-// when (true) {
-// numerator.isZero() -> "0"
-// denominator.isOne() -> numerator.toString(namer)
-// else -> "${numerator.toStringWithBrackets(namer)}/${denominator.toStringWithBrackets(namer)}"
-// }
-//
-// fun toStringWithBrackets(names: Map<Symbol, String> = emptyMap()): String =
-// when (true) {
-// numerator.isZero() -> "0"
-// denominator.isOne() -> numerator.toStringWithBrackets(names)
-// else -> "(${numerator.toStringWithBrackets(names)}/${denominator.toStringWithBrackets(names)})"
-// }
-//
-// fun toStringWithBrackets(namer: (Symbol) -> String): String =
-// when (true) {
-// numerator.isZero() -> "0"
-// denominator.isOne() -> numerator.toStringWithBrackets(namer)
-// else -> "(${numerator.toStringWithBrackets(namer)}/${denominator.toStringWithBrackets(namer)})"
-// }
-//
-// fun toReversedString(names: Map<Symbol, String> = emptyMap()): String =
-// when (true) {
-// numerator.isZero() -> "0"
-// denominator.isOne() -> numerator.toReversedString(names)
-// else -> "${numerator.toReversedStringWithBrackets(names)}/${denominator.toReversedStringWithBrackets(names)}"
-// }
-//
-// fun toReversedString(namer: (Symbol) -> String): String =
-// when (true) {
-// numerator.isZero() -> "0"
-// denominator.isOne() -> numerator.toReversedString(namer)
-// else -> "${numerator.toReversedStringWithBrackets(namer)}/${denominator.toReversedStringWithBrackets(namer)}"
-// }
-//
-// fun toReversedStringWithBrackets(names: Map<Symbol, String> = emptyMap()): String =
-// when (true) {
-// numerator.isZero() -> "0"
-// denominator.isOne() -> numerator.toReversedStringWithBrackets(names)
-// else -> "(${numerator.toReversedStringWithBrackets(names)}/${denominator.toReversedStringWithBrackets(names)})"
-// }
-//
-// fun toReversedStringWithBrackets(namer: (Symbol) -> String): String =
-// when (true) {
-// numerator.isZero() -> "0"
-// denominator.isOne() -> numerator.toReversedStringWithBrackets(namer)
-// else -> "(${numerator.toReversedStringWithBrackets(namer)}/${denominator.toReversedStringWithBrackets(namer)})"
-// }
-}
\ No newline at end of file
diff --git a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/ListPolynomial.kt b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/ListPolynomial.kt
index 585da95ea..fce179fc8 100644
--- a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/ListPolynomial.kt
+++ b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/ListPolynomial.kt
@@ -8,23 +8,19 @@ package space.kscience.kmath.functions
import space.kscience.kmath.operations.Ring
import space.kscience.kmath.operations.ScaleOperations
import space.kscience.kmath.operations.invoke
-import kotlin.contracts.InvocationKind
-import kotlin.contracts.contract
-import kotlin.experimental.ExperimentalTypeInference
-import kotlin.jvm.JvmName
import kotlin.math.max
import kotlin.math.min
/**
- * Polynomial model without fixation on specific context they are applied to.
+ * Represents univariate polynomial that stores its coefficients in a [List].
*
* @param coefficients constant is the leftmost coefficient.
*/
public data class ListPolynomial<C>(
/**
- * List that collects coefficients of the polynomial. Every monomial `a x^d` is represented as a coefficients
- * `a` placed into the list with index `d`. For example coefficients of polynomial `5 x^2 - 6` can be represented as
+ * List that contains coefficients of the polynomial. Every monomial `a x^d` is stored as a coefficient `a` placed
+ * into the list at index `d`. For example, coefficients of a polynomial `5 x^2 - 6` can be represented as
* ```
* listOf(
* -6, // -6 +
@@ -42,26 +38,28 @@ public data class ListPolynomial<C>(
* 0, // 0 x^4
* )
* ```
- * It is recommended not to put extra zeros at end of the list (as for `0x^3` and `0x^4` in the example), but is not
- * prohibited.
+ * It is not prohibited to put extra zeros at end of the list (as for `0x^3` and `0x^4` in the example). But the
+ * longer the coefficients list the worse performance of arithmetical operations performed on it. Thus, it is
+ * recommended not to put (or even to remove) extra (or useless) coefficients at the end of the coefficients list.
*/
public val coefficients: List<C>
) : Polynomial<C> {
- override fun toString(): String = "Polynomial$coefficients"
+ override fun toString(): String = "ListPolynomial$coefficients"
}
/**
- * Space of univariate polynomials constructed over ring.
+ * Arithmetic context for univariate polynomials with coefficients stored as a [List] constructed with the given [ring]
+ * of constants.
*
- * @param C the type of constants. Polynomials have them as a coefficients in their terms.
- * @param A type of underlying ring of constants. It's [Ring] of [C].
+ * @param C the type of constants. Polynomials have them a coefficients in their terms.
+ * @param A type of provided underlying ring of constants. It's [Ring] of [C].
* @param ring underlying ring of constants of type [A].
*/
public open class ListPolynomialSpace<C, A : Ring<C>>(
public override val ring: A,
) : PolynomialSpaceOverRing<C, ListPolynomial<C>, A> {
/**
- * Returns sum of the polynomial and the integer represented as polynomial.
+ * Returns sum of the polynomial and the integer represented as a polynomial.
*
* The operation is equivalent to adding [other] copies of unit polynomial to [this].
*/
@@ -79,7 +77,7 @@ public open class ListPolynomialSpace<C, A : Ring<C>>(
}
)
/**
- * Returns difference between the polynomial and the integer represented as polynomial.
+ * Returns difference between the polynomial and the integer represented as a polynomial.
*
* The operation is equivalent to subtraction [other] copies of unit polynomial from [this].
*/
@@ -97,7 +95,7 @@ public open class ListPolynomialSpace<C, A : Ring<C>>(
}
)
/**
- * Returns product of the polynomial and the integer represented as polynomial.
+ * Returns product of the polynomial and the integer represented as a polynomial.
*
* The operation is equivalent to sum of [other] copies of [this].
*/
@@ -112,7 +110,7 @@ public open class ListPolynomialSpace<C, A : Ring<C>>(
)
/**
- * Returns sum of the integer represented as polynomial and the polynomial.
+ * Returns sum of the integer represented as a polynomial and the polynomial.
*
* The operation is equivalent to adding [this] copies of unit polynomial to [other].
*/
@@ -130,7 +128,7 @@ public open class ListPolynomialSpace<C, A : Ring<C>>(
}
)
/**
- * Returns difference between the integer represented as polynomial and the polynomial.
+ * Returns difference between the integer represented as a polynomial and the polynomial.
*
* The operation is equivalent to subtraction [this] copies of unit polynomial from [other].
*/
@@ -150,7 +148,7 @@ public open class ListPolynomialSpace<C, A : Ring<C>>(
}
)
/**
- * Returns product of the integer represented as polynomial and the polynomial.
+ * Returns product of the integer represented as a polynomial and the polynomial.
*
* The operation is equivalent to sum of [this] copies of [other].
*/
@@ -170,7 +168,7 @@ public open class ListPolynomialSpace<C, A : Ring<C>>(
public override fun number(value: Int): ListPolynomial<C> = number(constantNumber(value))
/**
- * Returns sum of the constant represented as polynomial and the polynomial.
+ * Returns sum of the constant represented as a polynomial and the polynomial.
*/
public override operator fun C.plus(other: ListPolynomial<C>): ListPolynomial<C> =
with(other.coefficients) {
@@ -186,7 +184,7 @@ public open class ListPolynomialSpace<C, A : Ring<C>>(
)
}
/**
- * Returns difference between the constant represented as polynomial and the polynomial.
+ * Returns difference between the constant represented as a polynomial and the polynomial.
*/
public override operator fun C.minus(other: ListPolynomial<C>): ListPolynomial<C> =
with(other.coefficients) {
@@ -204,7 +202,7 @@ public open class ListPolynomialSpace<C, A : Ring<C>>(
)
}
/**
- * Returns product of the constant represented as polynomial and the polynomial.
+ * Returns product of the constant represented as a polynomial and the polynomial.
*/
public override operator fun C.times(other: ListPolynomial<C>): ListPolynomial<C> =
ListPolynomial(
@@ -216,7 +214,7 @@ public open class ListPolynomialSpace<C, A : Ring<C>>(
)
/**
- * Returns sum of the constant represented as polynomial and the polynomial.
+ * Returns sum of the constant represented as a polynomial and the polynomial.
*/
public override operator fun ListPolynomial<C>.plus(other: C): ListPolynomial<C> =
with(coefficients) {
@@ -232,7 +230,7 @@ public open class ListPolynomialSpace<C, A : Ring<C>>(
)
}
/**
- * Returns difference between the constant represented as polynomial and the polynomial.
+ * Returns difference between the constant represented as a polynomial and the polynomial.
*/
public override operator fun ListPolynomial<C>.minus(other: C): ListPolynomial<C> =
with(coefficients) {
@@ -248,7 +246,7 @@ public open class ListPolynomialSpace<C, A : Ring<C>>(
)
}
/**
- * Returns product of the constant represented as polynomial and the polynomial.
+ * Returns product of the constant represented as a polynomial and the polynomial.
*/
public override operator fun ListPolynomial<C>.times(other: C): ListPolynomial<C> =
ListPolynomial(
@@ -262,7 +260,7 @@ public open class ListPolynomialSpace<C, A : Ring<C>>(
/**
* Converts the constant [value] to polynomial.
*/
- public override fun number(value: C): ListPolynomial<C> = ListPolynomial(value)
+ public override fun number(value: C): ListPolynomial<C> = ListPolynomial(listOf(value))
/**
* Returns negation of the polynomial.
@@ -321,9 +319,9 @@ public open class ListPolynomialSpace<C, A : Ring<C>>(
*/
override val zero: ListPolynomial<C> = ListPolynomial(emptyList())
/**
- * Instance of unit constant (unit of the underlying ring).
+ * Instance of unit polynomial (unit of the polynomial ring).
*/
- override val one: ListPolynomial<C> = ListPolynomial(listOf(constantOne))
+ override val one: ListPolynomial<C> by lazy { ListPolynomial(listOf(constantOne)) }
/**
* Degree of the polynomial, [see also](https://en.wikipedia.org/wiki/Degree_of_a_polynomial). If the polynomial is
@@ -331,23 +329,43 @@ public open class ListPolynomialSpace<C, A : Ring<C>>(
*/
public override val ListPolynomial<C>.degree: Int get() = coefficients.lastIndex
+ // TODO: When context receivers will be ready move all of this substitutions and invocations to utilities with
+ // [ListPolynomialSpace] as a context receiver
+ /**
+ * Evaluates value of [this] polynomial on provided argument.
+ */
@Suppress("NOTHING_TO_INLINE")
public inline fun ListPolynomial<C>.substitute(argument: C): C = this.substitute(ring, argument)
+ /**
+ * Substitutes provided polynomial [argument] into [this] polynomial.
+ */
@Suppress("NOTHING_TO_INLINE")
public inline fun ListPolynomial<C>.substitute(argument: ListPolynomial<C>): ListPolynomial<C> = this.substitute(ring, argument)
+ /**
+ * Represent [this] polynomial as a regular context-less function.
+ */
@Suppress("NOTHING_TO_INLINE")
public inline fun ListPolynomial<C>.asFunction(): (C) -> C = { this.substitute(ring, it) }
+ /**
+ * Represent [this] polynomial as a regular context-less function.
+ */
@Suppress("NOTHING_TO_INLINE")
- public inline fun ListPolynomial<C>.asFunctionOnConstants(): (C) -> C = { this.substitute(ring, it) }
+ public inline fun ListPolynomial<C>.asFunctionOfConstant(): (C) -> C = { this.substitute(ring, it) }
+ /**
+ * Represent [this] polynomial as a regular context-less function.
+ */
@Suppress("NOTHING_TO_INLINE")
- public inline fun ListPolynomial<C>.asFunctionOnPolynomials(): (ListPolynomial<C>) -> ListPolynomial<C> = { this.substitute(ring, it) }
+ public inline fun ListPolynomial<C>.asFunctionOfPolynomial(): (ListPolynomial<C>) -> ListPolynomial<C> = { this.substitute(ring, it) }
/**
- * Evaluates the polynomial for the given value [argument].
+ * Evaluates value of [this] polynomial on provided [argument].
*/
@Suppress("NOTHING_TO_INLINE")
public inline operator fun ListPolynomial<C>.invoke(argument: C): C = this.substitute(ring, argument)
+ /**
+ * Evaluates value of [this] polynomial on provided [argument].
+ */
@Suppress("NOTHING_TO_INLINE")
public inline operator fun ListPolynomial<C>.invoke(argument: ListPolynomial<C>): ListPolynomial<C> = this.substitute(ring, argument)
}
diff --git a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/ListRationalFunction.kt b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/ListRationalFunction.kt
index 7b6c23ac3..f3e352bcd 100644
--- a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/ListRationalFunction.kt
+++ b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/ListRationalFunction.kt
@@ -8,13 +8,23 @@ package space.kscience.kmath.functions
import space.kscience.kmath.operations.Ring
+/**
+ * Represents rational function that stores its numerator and denominator as [ListPolynomial]s.
+ */
public data class ListRationalFunction<C>(
public override val numerator: ListPolynomial<C>,
public override val denominator: ListPolynomial<C>
) : RationalFunction<C, ListPolynomial<C>> {
- override fun toString(): String = "RationalFunction${numerator.coefficients}/${denominator.coefficients}"
+ override fun toString(): String = "ListRationalFunction${numerator.coefficients}/${denominator.coefficients}"
}
+/**
+ * Arithmetic context for univariate rational functions with numerator and denominator represented as [ListPolynomial]s.
+ *
+ * @param C the type of constants. Polynomials have them a coefficients in their terms.
+ * @param A type of provided underlying ring of constants. It's [Ring] of [C].
+ * @param ring underlying ring of constants of type [A].
+ */
public class ListRationalFunctionSpace<C, A : Ring<C>> (
public val ring: A,
) :
@@ -30,76 +40,98 @@ public class ListRationalFunctionSpace<C, A : Ring<C>> (
ListRationalFunction<C>,
>() {
+ /**
+ * Underlying polynomial ring. Its polynomial operations are inherited by local polynomial operations.
+ */
override val polynomialRing : ListPolynomialSpace<C, A> = ListPolynomialSpace(ring)
+ /**
+ * Constructor of [ListRationalFunction] from numerator and denominator [ListPolynomial].
+ */
override fun constructRationalFunction(numerator: ListPolynomial<C>, denominator: ListPolynomial<C>): ListRationalFunction<C> =
ListRationalFunction(numerator, denominator)
+ // TODO: When context receivers will be ready move all of this substitutions and invocations to utilities with
+ // [ListPolynomialSpace] as a context receiver
/**
- * Instance of zero rational function (zero of the rational functions ring).
+ * Evaluates value of [this] polynomial on provided argument.
*/
- public override val zero: ListRationalFunction<C> = ListRationalFunction(polynomialZero, polynomialOne)
+ @Suppress("NOTHING_TO_INLINE")
+ public inline fun ListPolynomial<C>.substitute(argument: C): C = this.substitute(ring, argument)
/**
- * Instance of unit polynomial (unit of the rational functions ring).
+ * Substitutes provided polynomial [argument] into [this] polynomial.
*/
- public override val one: ListRationalFunction<C> = ListRationalFunction(polynomialOne, polynomialOne)
+ @Suppress("NOTHING_TO_INLINE")
+ public inline fun ListPolynomial<C>.substitute(argument: ListPolynomial<C>): ListPolynomial<C> = this.substitute(ring, argument)
+ /**
+ * Substitutes provided rational function [argument] into [this] polynomial.
+ */
+ @Suppress("NOTHING_TO_INLINE")
+ public inline fun ListPolynomial<C>.substitute(argument: ListRationalFunction<C>): ListRationalFunction<C> = this.substitute(ring, argument)
+ /**
+ * Substitutes provided polynomial [argument] into [this] rational function.
+ */
+ @Suppress("NOTHING_TO_INLINE")
+ public inline fun ListRationalFunction<C>.substitute(argument: ListPolynomial<C>): ListRationalFunction<C> = this.substitute(ring, argument)
+ /**
+ * Substitutes provided rational function [argument] into [this] rational function.
+ */
+ @Suppress("NOTHING_TO_INLINE")
+ public inline fun ListRationalFunction<C>.substitute(argument: ListRationalFunction<C>): ListRationalFunction<C> = this.substitute(ring, argument)
- // TODO: Разобрать
+ /**
+ * Represent [this] polynomial as a regular context-less function.
+ */
+ @Suppress("NOTHING_TO_INLINE")
+ public inline fun ListPolynomial<C>.asFunction(): (C) -> C = { this.substitute(ring, it) }
+ /**
+ * Represent [this] polynomial as a regular context-less function.
+ */
+ @Suppress("NOTHING_TO_INLINE")
+ public inline fun ListPolynomial<C>.asFunctionOfConstant(): (C) -> C = { this.substitute(ring, it) }
+ /**
+ * Represent [this] polynomial as a regular context-less function.
+ */
+ @Suppress("NOTHING_TO_INLINE")
+ public inline fun ListPolynomial<C>.asFunctionOfPolynomial(): (ListPolynomial<C>) -> ListPolynomial<C> = { this.substitute(ring, it) }
+ /**
+ * Represent [this] polynomial as a regular context-less function.
+ */
+ @Suppress("NOTHING_TO_INLINE")
+ public inline fun ListPolynomial<C>.asFunctionOfRationalFunction(): (ListRationalFunction<C>) -> ListRationalFunction<C> = { this.substitute(ring, it) }
+ /**
+ * Represent [this] rational function as a regular context-less function.
+ */
+ @Suppress("NOTHING_TO_INLINE")
+ public inline fun ListRationalFunction<C>.asFunctionOfPolynomial(): (ListPolynomial<C>) -> ListRationalFunction<C> = { this.substitute(ring, it) }
+ /**
+ * Represent [this] rational function as a regular context-less function.
+ */
+ @Suppress("NOTHING_TO_INLINE")
+ public inline fun ListRationalFunction<C>.asFunctionOfRationalFunction(): (ListRationalFunction<C>) -> ListRationalFunction<C> = { this.substitute(ring, it) }
-// operator fun invoke(arg: UnivariatePolynomial<T>): RationalFunction<T> =
-// RationalFunction(
-// numerator(arg),
-// denominator(arg)
-// )
-//
-// operator fun invoke(arg: RationalFunction<T>): RationalFunction<T> {
-// val num = numerator invokeRFTakeNumerator arg
-// val den = denominator invokeRFTakeNumerator arg
-// val degreeDif = numeratorDegree - denominatorDegree
-// return if (degreeDif > 0)
-// RationalFunction(
-// num,
-// multiplyByPower(den, arg.denominator, degreeDif)
-// )
-// else
-// RationalFunction(
-// multiplyByPower(num, arg.denominator, -degreeDif),
-// den
-// )
-// }
-//
-// override fun toString(): String = toString(UnivariatePolynomial.variableName)
-//
-// fun toString(withVariableName: String = UnivariatePolynomial.variableName): String =
-// when(true) {
-// numerator.isZero() -> "0"
-// denominator.isOne() -> numerator.toString(withVariableName)
-// else -> "${numerator.toStringWithBrackets(withVariableName)}/${denominator.toStringWithBrackets(withVariableName)}"
-// }
-//
-// fun toStringWithBrackets(withVariableName: String = UnivariatePolynomial.variableName): String =
-// when(true) {
-// numerator.isZero() -> "0"
-// denominator.isOne() -> numerator.toStringWithBrackets(withVariableName)
-// else -> "(${numerator.toStringWithBrackets(withVariableName)}/${denominator.toStringWithBrackets(withVariableName)})"
-// }
-//
-// fun toReversedString(withVariableName: String = UnivariatePolynomial.variableName): String =
-// when(true) {
-// numerator.isZero() -> "0"
-// denominator.isOne() -> numerator.toReversedString(withVariableName)
-// else -> "${numerator.toReversedStringWithBrackets(withVariableName)}/${denominator.toReversedStringWithBrackets(withVariableName)}"
-// }
-//
-// fun toReversedStringWithBrackets(withVariableName: String = UnivariatePolynomial.variableName): String =
-// when(true) {
-// numerator.isZero() -> "0"
-// denominator.isOne() -> numerator.toReversedStringWithBrackets(withVariableName)
-// else -> "(${numerator.toReversedStringWithBrackets(withVariableName)}/${denominator.toReversedStringWithBrackets(withVariableName)})"
-// }
-//
-// fun removeZeros() =
-// RationalFunction(
-// numerator.removeZeros(),
-// denominator.removeZeros()
-// )
+ /**
+ * Evaluates value of [this] polynomial on provided argument.
+ */
+ @Suppress("NOTHING_TO_INLINE")
+ public inline operator fun ListPolynomial<C>.invoke(argument: C): C = this.substitute(ring, argument)
+ /**
+ * Evaluates value of [this] polynomial on provided argument.
+ */
+ @Suppress("NOTHING_TO_INLINE")
+ public inline operator fun ListPolynomial<C>.invoke(argument: ListPolynomial<C>): ListPolynomial<C> = this.substitute(ring, argument)
+ /**
+ * Evaluates value of [this] polynomial on provided argument.
+ */
+ @Suppress("NOTHING_TO_INLINE")
+ public inline operator fun ListPolynomial<C>.invoke(argument: ListRationalFunction<C>): ListRationalFunction<C> = this.substitute(ring, argument)
+ /**
+ * Evaluates value of [this] rational function on provided argument.
+ */
+ @Suppress("NOTHING_TO_INLINE")
+ public inline operator fun ListRationalFunction<C>.invoke(argument: ListPolynomial<C>): ListRationalFunction<C> = this.substitute(ring, argument)
+ /**
+ * Evaluates value of [this] rational function on provided argument.
+ */
+ @Suppress("NOTHING_TO_INLINE")
+ public inline operator fun ListRationalFunction<C>.invoke(argument: ListRationalFunction<C>): ListRationalFunction<C> = this.substitute(ring, argument)
}
\ No newline at end of file
diff --git a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/NumberedPolynomial.kt b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/NumberedPolynomial.kt
deleted file mode 100644
index e75373819..000000000
--- a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/NumberedPolynomial.kt
+++ /dev/null
@@ -1,389 +0,0 @@
-/*
- * Copyright 2018-2021 KMath contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package space.kscience.kmath.functions
-
-import space.kscience.kmath.operations.invoke
-import space.kscience.kmath.operations.Ring
-import space.kscience.kmath.operations.ScaleOperations
-import kotlin.contracts.InvocationKind
-import kotlin.contracts.contract
-import kotlin.experimental.ExperimentalTypeInference
-import kotlin.jvm.JvmName
-import kotlin.math.max
-
-
-/**
- * Polynomial model without fixation on specific context they are applied to.
- *
- * @param C the type of constants.
- */
-public data class NumberedPolynomial<C>
-internal constructor(
- /**
- * Map that collects coefficients of the polynomial. Every monomial `a x_1^{d_1} ... x_n^{d_n}` is represented as
- * pair "key-value" in the map, where value is coefficients `a` and
- * key is list that associates index of every variable in the monomial with multiplicity of the variable occurring
- * in the monomial. For example coefficients of polynomial `5 x_1^2 x_3^3 - 6 x_2` can be represented as
- * ```
- * mapOf(
- * listOf(2, 0, 3) to 5,
- * listOf(0, 1) to (-6),
- * )
- * ```
- * and also as
- * ```
- * mapOf(
- * listOf(2, 0, 3) to 5,
- * listOf(0, 1) to (-6),
- * listOf(0, 1, 1) to 0,
- * )
- * ```
- * It is recommended not to put zero monomials into the map, but is not prohibited. Lists of degrees always do not
- * contain any zeros on end, but can contain zeros on start or anywhere in middle.
- */
- public val coefficients: Map<List<UInt>, C>
-) : Polynomial<C> {
- override fun toString(): String = "NumberedPolynomial$coefficients"
-}
-
-/**
- * Space of polynomials.
- *
- * @param C the type of operated polynomials.
- * @param A the intersection of [Ring] of [C] and [ScaleOperations] of [C].
- * @param ring the [A] instance.
- */
-public open class NumberedPolynomialSpace<C, A : Ring<C>>(
- public final override val ring: A,
-) : PolynomialSpaceOverRing<C, NumberedPolynomial<C>, A> {
- /**
- * Returns sum of the polynomial and the integer represented as polynomial.
- *
- * The operation is equivalent to adding [other] copies of unit polynomial to [this].
- */
- public override operator fun NumberedPolynomial<C>.plus(other: Int): NumberedPolynomial<C> =
- if (other == 0) this
- else
- NumberedPolynomial(
- coefficients
- .toMutableMap()
- .apply {
- val degs = emptyList<UInt>()
-
- this[degs] = getOrElse(degs) { constantZero } + other
- }
- )
- /**
- * Returns difference between the polynomial and the integer represented as polynomial.
- *
- * The operation is equivalent to subtraction [other] copies of unit polynomial from [this].
- */
- public override operator fun NumberedPolynomial<C>.minus(other: Int): NumberedPolynomial<C> =
- if (other == 0) this
- else
- NumberedPolynomial(
- coefficients
- .toMutableMap()
- .apply {
- val degs = emptyList<UInt>()
-
- this[degs] = getOrElse(degs) { constantZero } - other
- }
- )
- /**
- * Returns product of the polynomial and the integer represented as polynomial.
- *
- * The operation is equivalent to sum of [other] copies of [this].
- */
- public override operator fun NumberedPolynomial<C>.times(other: Int): NumberedPolynomial<C> =
- if (other == 0) zero
- else NumberedPolynomial<C>(
- coefficients
- .toMutableMap()
- .apply {
- for (degs in keys) this[degs] = this[degs]!! * other
- }
- )
-
- /**
- * Returns sum of the integer represented as polynomial and the polynomial.
- *
- * The operation is equivalent to adding [this] copies of unit polynomial to [other].
- */
- public override operator fun Int.plus(other: NumberedPolynomial<C>): NumberedPolynomial<C> =
- if (this == 0) other
- else
- NumberedPolynomial(
- other.coefficients
- .toMutableMap()
- .apply {
- val degs = emptyList<UInt>()
-
- this[degs] = this@plus + getOrElse(degs) { constantZero }
- }
- )
- /**
- * Returns difference between the integer represented as polynomial and the polynomial.
- *
- * The operation is equivalent to subtraction [this] copies of unit polynomial from [other].
- */
- public override operator fun Int.minus(other: NumberedPolynomial<C>): NumberedPolynomial<C> =
- if (this == 0) other
- else
- NumberedPolynomial(
- other.coefficients
- .toMutableMap()
- .apply {
- val degs = emptyList<UInt>()
-
- this[degs] = this@minus - getOrElse(degs) { constantZero }
- }
- )
- /**
- * Returns product of the integer represented as polynomial and the polynomial.
- *
- * The operation is equivalent to sum of [this] copies of [other].
- */
- public override operator fun Int.times(other: NumberedPolynomial<C>): NumberedPolynomial<C> =
- if (this == 0) zero
- else NumberedPolynomial(
- other.coefficients
- .toMutableMap()
- .apply {
- for (degs in keys) this[degs] = this@times * this[degs]!!
- }
- )
-
- /**
- * Converts the integer [value] to polynomial.
- */
- public override fun number(value: Int): NumberedPolynomial<C> = number(constantNumber(value))
-
- /**
- * Returns sum of the constant represented as polynomial and the polynomial.
- */
- override operator fun C.plus(other: NumberedPolynomial<C>): NumberedPolynomial<C> =
- with(other.coefficients) {
- if (isEmpty()) NumberedPolynomial<C>(mapOf(emptyList<UInt>() to this@plus))
- else NumberedPolynomial<C>(
- toMutableMap()
- .apply {
- val degs = emptyList<UInt>()
-
- this[degs] = this@plus + getOrElse(degs) { constantZero }
- }
- )
- }
- /**
- * Returns difference between the constant represented as polynomial and the polynomial.
- */
- override operator fun C.minus(other: NumberedPolynomial<C>): NumberedPolynomial<C> =
- with(other.coefficients) {
- if (isEmpty()) NumberedPolynomial<C>(mapOf(emptyList<UInt>() to this@minus))
- else NumberedPolynomial<C>(
- toMutableMap()
- .apply {
- forEach { (degs, c) -> if(degs.isNotEmpty()) this[degs] = -c }
-
- val degs = emptyList<UInt>()
-
- this[degs] = this@minus - getOrElse(degs) { constantZero }
- }
- )
- }
- /**
- * Returns product of the constant represented as polynomial and the polynomial.
- */
- override operator fun C.times(other: NumberedPolynomial<C>): NumberedPolynomial<C> =
- NumberedPolynomial<C>(
- other.coefficients
- .toMutableMap()
- .apply {
- for (degs in keys) this[degs] = this@times * this[degs]!!
- }
- )
-
- /**
- * Returns sum of the constant represented as polynomial and the polynomial.
- */
- override operator fun NumberedPolynomial<C>.plus(other: C): NumberedPolynomial<C> =
- with(coefficients) {
- if (isEmpty()) NumberedPolynomial<C>(mapOf(emptyList<UInt>() to other))
- else NumberedPolynomial<C>(
- toMutableMap()
- .apply {
- val degs = emptyList<UInt>()
-
- this[degs] = getOrElse(degs) { constantZero } + other
- }
- )
- }
- /**
- * Returns difference between the constant represented as polynomial and the polynomial.
- */
- override operator fun NumberedPolynomial<C>.minus(other: C): NumberedPolynomial<C> =
- with(coefficients) {
- if (isEmpty()) NumberedPolynomial<C>(mapOf(emptyList<UInt>() to other))
- else NumberedPolynomial<C>(
- toMutableMap()
- .apply {
- val degs = emptyList<UInt>()
-
- this[degs] = getOrElse(degs) { constantZero } - other
- }
- )
- }
- /**
- * Returns product of the constant represented as polynomial and the polynomial.
- */
- override operator fun NumberedPolynomial<C>.times(other: C): NumberedPolynomial<C> =
- NumberedPolynomial<C>(
- coefficients
- .toMutableMap()
- .apply {
- for (degs in keys) this[degs] = this[degs]!! * other
- }
- )
-
- /**
- * Converts the constant [value] to polynomial.
- */
- public override fun number(value: C): NumberedPolynomial<C> =
- NumberedPolynomial(mapOf(emptyList<UInt>() to value))
-
- /**
- * Returns negation of the polynomial.
- */
- override fun NumberedPolynomial<C>.unaryMinus(): NumberedPolynomial<C> =
- NumberedPolynomial<C>(
- coefficients.mapValues { -it.value }
- )
- /**
- * Returns sum of the polynomials.
- */
- override operator fun NumberedPolynomial<C>.plus(other: NumberedPolynomial<C>): NumberedPolynomial<C> =
- NumberedPolynomial<C>(
- buildMap(coefficients.size + other.coefficients.size) {
- other.coefficients.mapValuesTo(this) { it.value }
- other.coefficients.mapValuesTo(this) { (key, value) -> if (key in this) this[key]!! + value else value }
- }
- )
- /**
- * Returns difference of the polynomials.
- */
- override operator fun NumberedPolynomial<C>.minus(other: NumberedPolynomial<C>): NumberedPolynomial<C> =
- NumberedPolynomial<C>(
- buildMap(coefficients.size + other.coefficients.size) {
- other.coefficients.mapValuesTo(this) { it.value }
- other.coefficients.mapValuesTo(this) { (key, value) -> if (key in this) this[key]!! - value else -value }
- }
- )
- /**
- * Returns product of the polynomials.
- */
- override operator fun NumberedPolynomial<C>.times(other: NumberedPolynomial<C>): NumberedPolynomial<C> =
- NumberedPolynomial<C>(
- buildMap(coefficients.size * other.coefficients.size) {
- for ((degs1, c1) in coefficients) for ((degs2, c2) in other.coefficients) {
- val degs =
- (0..max(degs1.lastIndex, degs2.lastIndex))
- .map { degs1.getOrElse(it) { 0U } + degs2.getOrElse(it) { 0U } }
- val c = c1 * c2
- this[degs] = if (degs in this) this[degs]!! + c else c
- }
- }
- )
-
- /**
- * Instance of zero polynomial (zero of the polynomial ring).
- */
- override val zero: NumberedPolynomial<C> = NumberedPolynomial<C>(emptyMap())
- /**
- * Instance of unit polynomial (unit of the polynomial ring).
- */
- override val one: NumberedPolynomial<C> =
- NumberedPolynomial<C>(
- mapOf(
- emptyList<UInt>() to constantOne // 1 * x_1^0 * x_2^0 * ...
- )
- )
-
- /**
- * Maximal index (ID) of variable occurring in the polynomial with positive power. If there is no such variable,
- * the result is `-1`.
- */
- public val NumberedPolynomial<C>.lastVariable: Int
- get() = coefficients.entries.maxOfOrNull { (degs, _) -> degs.lastIndex } ?: -1
- /**
- * Degree of the polynomial, [see also](https://en.wikipedia.org/wiki/Degree_of_a_polynomial). If the polynomial is
- * zero, degree is -1.
- */
- override val NumberedPolynomial<C>.degree: Int
- get() = coefficients.entries.maxOfOrNull { (degs, _) -> degs.sum().toInt() } ?: -1
- /**
- * List that associates indices of variables (that appear in the polynomial in positive exponents) with their most
- * exponents in which the variables are appeared in the polynomial.
- *
- * As consequence all values in the list are non-negative integers. Also, if the polynomial is constant, the list is empty.
- * And last index of the list is [lastVariable].
- */
- public val NumberedPolynomial<C>.degrees: List<UInt>
- get() =
- MutableList(lastVariable + 1) { 0u }.apply {
- coefficients.entries.forEach { (degs, _) ->
- degs.forEachIndexed { index, deg ->
- this[index] = max(this[index], deg)
- }
- }
- }
- /**
- * Counts degree of the polynomial by the specified [variable].
- */
- public fun NumberedPolynomial<C>.degreeBy(variable: Int): UInt =
- coefficients.entries.maxOfOrNull { (degs, _) -> degs.getOrElse(variable) { 0u } } ?: 0u
- /**
- * Counts degree of the polynomial by the specified [variables].
- */
- public fun NumberedPolynomial<C>.degreeBy(variables: Collection<Int>): UInt =
- coefficients.entries.maxOfOrNull { (degs, _) ->
- degs.withIndex().filter { (index, _) -> index in variables }.sumOf { it.value }
- } ?: 0u
- /**
- * Count of variables occurring in the polynomial with positive power. If there is no such variable,
- * the result is `0`.
- */
- public val NumberedPolynomial<C>.countOfVariables: Int
- get() =
- MutableList(lastVariable + 1) { false }.apply {
- coefficients.entries.forEach { (degs, _) ->
- degs.forEachIndexed { index, deg ->
- if (deg != 0u) this[index] = true
- }
- }
- }.count { it }
-
- @Suppress("NOTHING_TO_INLINE")
- public inline fun NumberedPolynomial<C>.substitute(argument: Map<Int, C>): NumberedPolynomial<C> = this.substitute(ring, argument)
- @Suppress("NOTHING_TO_INLINE")
- @JvmName("substitutePolynomial")
- public inline fun NumberedPolynomial<C>.substitute(argument: Map<Int, NumberedPolynomial<C>>): NumberedPolynomial<C> = this.substitute(ring, argument)
-
- @Suppress("NOTHING_TO_INLINE")
- public inline fun NumberedPolynomial<C>.asFunction(): (Map<Int, C>) -> NumberedPolynomial<C> = { this.substitute(ring, it) }
- @Suppress("NOTHING_TO_INLINE")
- public inline fun NumberedPolynomial<C>.asFunctionOnConstants(): (Map<Int, C>) -> NumberedPolynomial<C> = { this.substitute(ring, it) }
- @Suppress("NOTHING_TO_INLINE")
- public inline fun NumberedPolynomial<C>.asFunctionOnPolynomials(): (Map<Int, NumberedPolynomial<C>>) -> NumberedPolynomial<C> = { this.substitute(ring, it) }
-
- @Suppress("NOTHING_TO_INLINE")
- public inline operator fun NumberedPolynomial<C>.invoke(argument: Map<Int, C>): NumberedPolynomial<C> = this.substitute(ring, argument)
- @Suppress("NOTHING_TO_INLINE")
- @JvmName("invokePolynomial")
- public inline operator fun NumberedPolynomial<C>.invoke(argument: Map<Int, NumberedPolynomial<C>>): NumberedPolynomial<C> = this.substitute(ring, argument)
-
- // FIXME: Move to other constructors with context receiver
- public fun C.asNumberedPolynomial() : NumberedPolynomial<C> = NumberedPolynomial<C>(mapOf(emptyList<UInt>() to this))
-}
\ No newline at end of file
diff --git a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/NumberedRationalFunction.kt b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/NumberedRationalFunction.kt
deleted file mode 100644
index 30c7f0188..000000000
--- a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/NumberedRationalFunction.kt
+++ /dev/null
@@ -1,188 +0,0 @@
-/*
- * Copyright 2018-2021 KMath contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package space.kscience.kmath.functions
-
-import space.kscience.kmath.operations.Ring
-import space.kscience.kmath.operations.invoke
-import kotlin.math.max
-
-
-public class NumberedRationalFunction<C> internal constructor(
- public override val numerator: NumberedPolynomial<C>,
- public override val denominator: NumberedPolynomial<C>
-) : RationalFunction<C, NumberedPolynomial<C>> {
- override fun toString(): String = "NumberedRationalFunction${numerator.coefficients}/${denominator.coefficients}"
-}
-
-public class NumberedRationalFunctionSpace<C, A: Ring<C>> (
- public val ring: A,
-) :
- RationalFunctionalSpaceOverPolynomialSpace<
- C,
- NumberedPolynomial<C>,
- NumberedRationalFunction<C>,
- NumberedPolynomialSpace<C, A>,
- >,
- PolynomialSpaceOfFractions<
- C,
- NumberedPolynomial<C>,
- NumberedRationalFunction<C>,
- >() {
-
- override val polynomialRing : NumberedPolynomialSpace<C, A> = NumberedPolynomialSpace(ring)
- override fun constructRationalFunction(
- numerator: NumberedPolynomial<C>,
- denominator: NumberedPolynomial<C>
- ): NumberedRationalFunction<C> =
- NumberedRationalFunction(numerator, denominator)
-
- /**
- * Instance of zero rational function (zero of the rational functions ring).
- */
- public override val zero: NumberedRationalFunction<C> = NumberedRationalFunction(polynomialZero, polynomialOne)
- /**
- * Instance of unit polynomial (unit of the rational functions ring).
- */
- public override val one: NumberedRationalFunction<C> = NumberedRationalFunction(polynomialOne, polynomialOne)
-
- /**
- * Maximal index (ID) of variable occurring in the polynomial with positive power. If there is no such variable,
- * the result is `-1`.
- */
- public val NumberedPolynomial<C>.lastVariable: Int get() = polynomialRing { lastVariable }
- /**
- * List that associates indices of variables (that appear in the polynomial in positive exponents) with their most
- * exponents in which the variables are appeared in the polynomial.
- *
- * As consequence all values in the list are non-negative integers. Also, if the polynomial is constant, the list is empty.
- * And last index of the list is [lastVariable].
- */
- public val NumberedPolynomial<C>.degrees: List<UInt> get() = polynomialRing { degrees }
- /**
- * Counts degree of the polynomial by the specified [variable].
- */
- public fun NumberedPolynomial<C>.degreeBy(variable: Int): UInt = polynomialRing { degreeBy(variable) }
- /**
- * Counts degree of the polynomial by the specified [variables].
- */
- public fun NumberedPolynomial<C>.degreeBy(variables: Collection<Int>): UInt = polynomialRing { degreeBy(variables) }
- /**
- * Count of variables occurring in the polynomial with positive power. If there is no such variable,
- * the result is `0`.
- */
- public val NumberedPolynomial<C>.countOfVariables: Int get() = polynomialRing { countOfVariables }
-
- /**
- * Count of all variables that appear in the polynomial in positive exponents.
- */
- public val NumberedRationalFunction<C>.lastVariable: Int
- get() = polynomialRing { max(numerator.lastVariable, denominator.lastVariable) }
- /**
- * Count of variables occurring in the rational function with positive power. If there is no such variable,
- * the result is `0`.
- */
- public val NumberedRationalFunction<C>.countOfVariables: Int
- get() =
- MutableList(lastVariable + 1) { false }.apply {
- numerator.coefficients.entries.forEach { (degs, _) ->
- degs.forEachIndexed { index, deg ->
- if (deg != 0u) this[index] = true
- }
- }
- denominator.coefficients.entries.forEach { (degs, _) ->
- degs.forEachIndexed { index, deg ->
- if (deg != 0u) this[index] = true
- }
- }
- }.count { it }
-
- // TODO: Разобрать
-
-// operator fun invoke(arg: Map<Int, C>): NumberedRationalFunction<C> =
-// NumberedRationalFunction(
-// numerator(arg),
-// denominator(arg)
-// )
-//
-// @JvmName("invokePolynomial")
-// operator fun invoke(arg: Map<Int, Polynomial<C>>): NumberedRationalFunction<C> =
-// NumberedRationalFunction(
-// numerator(arg),
-// denominator(arg)
-// )
-//
-// @JvmName("invokeRationalFunction")
-// operator fun invoke(arg: Map<Int, NumberedRationalFunction<C>>): NumberedRationalFunction<C> {
-// var num = numerator invokeRFTakeNumerator arg
-// var den = denominator invokeRFTakeNumerator arg
-// for (variable in 0 until max(numerator.countOfVariables, denominator.countOfVariables)) if (variable in arg) {
-// val degreeDif = numerator.degrees.getOrElse(variable) { 0 } - denominator.degrees.getOrElse(variable) { 0 }
-// if (degreeDif > 0)
-// den = multiplyByPower(den, arg[variable]!!.denominator, degreeDif)
-// else
-// num = multiplyByPower(num, arg[variable]!!.denominator, -degreeDif)
-// }
-// return NumberedRationalFunction(num, den)
-// }
-//
-// override fun toString(): String = toString(Polynomial.variableName)
-//
-// fun toString(withVariableName: String = Polynomial.variableName): String =
-// when(true) {
-// numerator.isZero() -> "0"
-// denominator.isOne() -> numerator.toString(withVariableName)
-// else -> "${numerator.toStringWithBrackets(withVariableName)}/${denominator.toStringWithBrackets(withVariableName)}"
-// }
-//
-// fun toString(namer: (Int) -> String): String =
-// when(true) {
-// numerator.isZero() -> "0"
-// denominator.isOne() -> numerator.toString(namer)
-// else -> "${numerator.toStringWithBrackets(namer)}/${denominator.toStringWithBrackets(namer)}"
-// }
-//
-// fun toStringWithBrackets(withVariableName: String = Polynomial.variableName): String =
-// when(true) {
-// numerator.isZero() -> "0"
-// denominator.isOne() -> numerator.toStringWithBrackets(withVariableName)
-// else -> "(${numerator.toStringWithBrackets(withVariableName)}/${denominator.toStringWithBrackets(withVariableName)})"
-// }
-//
-// fun toStringWithBrackets(namer: (Int) -> String): String =
-// when(true) {
-// numerator.isZero() -> "0"
-// denominator.isOne() -> numerator.toStringWithBrackets(namer)
-// else -> "(${numerator.toStringWithBrackets(namer)}/${denominator.toStringWithBrackets(namer)})"
-// }
-//
-// fun toReversedString(withVariableName: String = Polynomial.variableName): String =
-// when(true) {
-// numerator.isZero() -> "0"
-// denominator.isOne() -> numerator.toReversedString(withVariableName)
-// else -> "${numerator.toReversedStringWithBrackets(withVariableName)}/${denominator.toReversedStringWithBrackets(withVariableName)}"
-// }
-//
-// fun toReversedString(namer: (Int) -> String): String =
-// when(true) {
-// numerator.isZero() -> "0"
-// denominator.isOne() -> numerator.toReversedString(namer)
-// else -> "${numerator.toReversedStringWithBrackets(namer)}/${denominator.toReversedStringWithBrackets(namer)}"
-// }
-//
-// fun toReversedStringWithBrackets(withVariableName: String = Polynomial.variableName): String =
-// when(true) {
-// numerator.isZero() -> "0"
-// denominator.isOne() -> numerator.toReversedStringWithBrackets(withVariableName)
-// else -> "(${numerator.toReversedStringWithBrackets(withVariableName)}/${denominator.toReversedStringWithBrackets(withVariableName)})"
-// }
-//
-// fun toReversedStringWithBrackets(namer: (Int) -> String): String =
-// when(true) {
-// numerator.isZero() -> "0"
-// denominator.isOne() -> numerator.toReversedStringWithBrackets(namer)
-// else -> "(${numerator.toReversedStringWithBrackets(namer)}/${denominator.toReversedStringWithBrackets(namer)})"
-// }
-}
\ No newline at end of file
diff --git a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/Polynomial.kt b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/Polynomial.kt
index e201f1f6e..12490d133 100644
--- a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/Polynomial.kt
+++ b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/Polynomial.kt
@@ -25,38 +25,38 @@ public interface Polynomial<C>
@Suppress("INAPPLICABLE_JVM_NAME", "PARAMETER_NAME_CHANGED_ON_OVERRIDE") // FIXME: Waiting for KT-31420
public interface PolynomialSpace<C, P: Polynomial<C>> : Ring<P> {
/**
- * Returns sum of the constant and the integer represented as constant (member of underlying ring).
+ * Returns sum of the constant and the integer represented as a constant (member of underlying ring).
*
* The operation is equivalent to adding [other] copies of unit of underlying ring to [this].
*/
public operator fun C.plus(other: Int): C
/**
- * Returns difference between the constant and the integer represented as constant (member of underlying ring).
+ * Returns difference between the constant and the integer represented as a constant (member of underlying ring).
*
* The operation is equivalent to subtraction [other] copies of unit of underlying ring from [this].
*/
public operator fun C.minus(other: Int): C
/**
- * Returns product of the constant and the integer represented as constant (member of underlying ring).
+ * Returns product of the constant and the integer represented as a constant (member of underlying ring).
*
* The operation is equivalent to sum of [other] copies of [this].
*/
public operator fun C.times(other: Int): C
/**
- * Returns sum of the integer represented as constant (member of underlying ring) and the constant.
+ * Returns sum of the integer represented as a constant (member of underlying ring) and the constant.
*
* The operation is equivalent to adding [this] copies of unit of underlying ring to [other].
*/
public operator fun Int.plus(other: C): C
/**
- * Returns difference between the integer represented as constant (member of underlying ring) and the constant.
+ * Returns difference between the integer represented as a constant (member of underlying ring) and the constant.
*
* The operation is equivalent to subtraction [this] copies of unit of underlying ring from [other].
*/
public operator fun Int.minus(other: C): C
/**
- * Returns product of the integer represented as constant (member of underlying ring) and the constant.
+ * Returns product of the integer represented as a constant (member of underlying ring) and the constant.
*
* The operation is equivalent to sum of [this] copies of [other].
*/
@@ -72,38 +72,38 @@ public interface PolynomialSpace<C, P: Polynomial<C>> : Ring<P> {
public fun Int.asConstant(): C = constantNumber(this)
/**
- * Returns sum of the polynomial and the integer represented as polynomial.
+ * Returns sum of the polynomial and the integer represented as a polynomial.
*
* The operation is equivalent to adding [other] copies of unit polynomial to [this].
*/
public operator fun P.plus(other: Int): P = addMultipliedByDoubling(this, one, other)
/**
- * Returns difference between the polynomial and the integer represented as polynomial.
+ * Returns difference between the polynomial and the integer represented as a polynomial.
*
* The operation is equivalent to subtraction [other] copies of unit polynomial from [this].
*/
public operator fun P.minus(other: Int): P = addMultipliedByDoubling(this, one, -other)
/**
- * Returns product of the polynomial and the integer represented as polynomial.
+ * Returns product of the polynomial and the integer represented as a polynomial.
*
* The operation is equivalent to sum of [other] copies of [this].
*/
public operator fun P.times(other: Int): P = multiplyByDoubling(this, other)
/**
- * Returns sum of the integer represented as polynomial and the polynomial.
+ * Returns sum of the integer represented as a polynomial and the polynomial.
*
* The operation is equivalent to adding [this] copies of unit polynomial to [other].
*/
public operator fun Int.plus(other: P): P = addMultipliedByDoubling(other, one, this)
/**
- * Returns difference between the integer represented as polynomial and the polynomial.
+ * Returns difference between the integer represented as a polynomial and the polynomial.
*
* The operation is equivalent to subtraction [this] copies of unit polynomial from [other].
*/
public operator fun Int.minus(other: P): P = addMultipliedByDoubling(-other, one, this)
/**
- * Returns product of the integer represented as polynomial and the polynomial.
+ * Returns product of the integer represented as a polynomial and the polynomial.
*
* The operation is equivalent to sum of [this] copies of [other].
*/
@@ -165,28 +165,28 @@ public interface PolynomialSpace<C, P: Polynomial<C>> : Ring<P> {
public val constantOne: C
/**
- * Returns sum of the constant represented as polynomial and the polynomial.
+ * Returns sum of the constant represented as a polynomial and the polynomial.
*/
public operator fun C.plus(other: P): P
/**
- * Returns difference between the constant represented as polynomial and the polynomial.
+ * Returns difference between the constant represented as a polynomial and the polynomial.
*/
public operator fun C.minus(other: P): P
/**
- * Returns product of the constant represented as polynomial and the polynomial.
+ * Returns product of the constant represented as a polynomial and the polynomial.
*/
public operator fun C.times(other: P): P
/**
- * Returns sum of the constant represented as polynomial and the polynomial.
+ * Returns sum of the constant represented as a polynomial and the polynomial.
*/
public operator fun P.plus(other: C): P
/**
- * Returns difference between the constant represented as polynomial and the polynomial.
+ * Returns difference between the constant represented as a polynomial and the polynomial.
*/
public operator fun P.minus(other: C): P
/**
- * Returns product of the constant represented as polynomial and the polynomial.
+ * Returns product of the constant represented as a polynomial and the polynomial.
*/
public operator fun P.times(other: C): P
@@ -254,41 +254,44 @@ public interface PolynomialSpace<C, P: Polynomial<C>> : Ring<P> {
@Suppress("INAPPLICABLE_JVM_NAME") // FIXME: Waiting for KT-31420
public interface PolynomialSpaceOverRing<C, P: Polynomial<C>, A: Ring<C>> : PolynomialSpace<C, P> {
+ /**
+ * Underlying ring of constants. Its operations on constants are inherited by local operations on constants.
+ */
public val ring: A
/**
- * Returns sum of the constant and the integer represented as constant (member of underlying ring).
+ * Returns sum of the constant and the integer represented as a constant (member of underlying ring).
*
* The operation is equivalent to adding [other] copies of unit of underlying ring to [this].
*/
public override operator fun C.plus(other: Int): C = ring { addMultipliedByDoubling(this@plus, one, other) }
/**
- * Returns difference between the constant and the integer represented as constant (member of underlying ring).
+ * Returns difference between the constant and the integer represented as a constant (member of underlying ring).
*
* The operation is equivalent to subtraction [other] copies of unit of underlying ring from [this].
*/
public override operator fun C.minus(other: Int): C = ring { addMultipliedByDoubling(this@minus, one, -other) }
/**
- * Returns product of the constant and the integer represented as constant (member of underlying ring).
+ * Returns product of the constant and the integer represented as a constant (member of underlying ring).
*
* The operation is equivalent to sum of [other] copies of [this].
*/
public override operator fun C.times(other: Int): C = ring { multiplyByDoubling(this@times, other) }
/**
- * Returns sum of the integer represented as constant (member of underlying ring) and the constant.
+ * Returns sum of the integer represented as a constant (member of underlying ring) and the constant.
*
* The operation is equivalent to adding [this] copies of unit of underlying ring to [other].
*/
public override operator fun Int.plus(other: C): C = ring { addMultipliedByDoubling(other, one, this@plus) }
/**
- * Returns difference between the integer represented as constant (member of underlying ring) and the constant.
+ * Returns difference between the integer represented as a constant (member of underlying ring) and the constant.
*
* The operation is equivalent to subtraction [this] copies of unit of underlying ring from [other].
*/
public override operator fun Int.minus(other: C): C = ring { addMultipliedByDoubling(-other, one, this@minus) }
/**
- * Returns product of the integer represented as constant (member of underlying ring) and the constant.
+ * Returns product of the integer represented as a constant (member of underlying ring) and the constant.
*
* The operation is equivalent to sum of [this] copies of [other].
*/
@@ -330,58 +333,145 @@ public interface PolynomialSpaceOverRing<C, P: Polynomial<C>, A: Ring<C>> : Poly
public override val constantOne: C get() = ring.one
}
+/**
+ * Abstraction of ring of polynomials of type [P] of variables of type [V] and over ring of constants of type [C].
+ *
+ * @param C the type of constants. Polynomials have them as coefficients in their terms.
+ * @param V the type of variables. Polynomials have them in representations of terms.
+ * @param P the type of polynomials.
+ */
@Suppress("INAPPLICABLE_JVM_NAME") // FIXME: Waiting for KT-31420
public interface MultivariatePolynomialSpace<C, V, P: Polynomial<C>>: PolynomialSpace<C, P> {
+ /**
+ * Returns sum of the variable represented as a monic monomial and the integer represented as a constant polynomial.
+ */
@JvmName("plusVariableInt")
public operator fun V.plus(other: Int): P
+ /**
+ * Returns difference between the variable represented as a monic monomial and the integer represented as a constant polynomial.
+ */
@JvmName("minusVariableInt")
public operator fun V.minus(other: Int): P
+ /**
+ * Returns product of the variable represented as a monic monomial and the integer represented as a constant polynomial.
+ */
@JvmName("timesVariableInt")
public operator fun V.times(other: Int): P
+ /**
+ * Returns sum of the integer represented as a constant polynomial and the variable represented as a monic monomial.
+ */
@JvmName("plusIntVariable")
public operator fun Int.plus(other: V): P
+ /**
+ * Returns difference between the integer represented as a constant polynomial and the variable represented as a monic monomial.
+ */
@JvmName("minusIntVariable")
public operator fun Int.minus(other: V): P
+ /**
+ * Returns product of the integer represented as a constant polynomial and the variable represented as a monic monomial.
+ */
@JvmName("timesIntVariable")
public operator fun Int.times(other: V): P
- @JvmName("plusConstantVariable")
- public operator fun C.plus(other: V): P
- @JvmName("minusConstantVariable")
- public operator fun C.minus(other: V): P
- @JvmName("timesConstantVariable")
- public operator fun C.times(other: V): P
-
+ /**
+ * Returns sum of the variable represented as a monic monomial and the constant represented as a constant polynomial.
+ */
@JvmName("plusVariableConstant")
public operator fun V.plus(other: C): P
+ /**
+ * Returns difference between the variable represented as a monic monomial and the constant represented as a constant polynomial.
+ */
@JvmName("minusVariableConstant")
public operator fun V.minus(other: C): P
+ /**
+ * Returns product of the variable represented as a monic monomial and the constant represented as a constant polynomial.
+ */
@JvmName("timesVariableConstant")
public operator fun V.times(other: C): P
+ /**
+ * Returns sum of the constant represented as a constant polynomial and the variable represented as a monic monomial.
+ */
+ @JvmName("plusConstantVariable")
+ public operator fun C.plus(other: V): P
+ /**
+ * Returns difference between the constant represented as a constant polynomial and the variable represented as a monic monomial.
+ */
+ @JvmName("minusConstantVariable")
+ public operator fun C.minus(other: V): P
+ /**
+ * Returns product of the constant represented as a constant polynomial and the variable represented as a monic monomial.
+ */
+ @JvmName("timesConstantVariable")
+ public operator fun C.times(other: V): P
+
+ /**
+ * Represents the variable as a monic monomial.
+ */
@JvmName("unaryPlusVariable")
public operator fun V.unaryPlus(): P
+ /**
+ * Returns negation of representation of the variable as a monic monomial.
+ */
@JvmName("unaryMinusVariable")
public operator fun V.unaryMinus(): P
+ /**
+ * Returns sum of the variables represented as monic monomials.
+ */
@JvmName("plusVariableVariable")
public operator fun V.plus(other: V): P
+ /**
+ * Returns difference between the variables represented as monic monomials.
+ */
@JvmName("minusVariableVariable")
public operator fun V.minus(other: V): P
+ /**
+ * Returns product of the variables represented as monic monomials.
+ */
@JvmName("timesVariableVariable")
public operator fun V.times(other: V): P
+ /**
+ * Represents the [variable] as a monic monomial.
+ */
+ @JvmName("numberVariable")
+ public fun number(variable: V): P = +variable
+ /**
+ * Represents the variable as a monic monomial.
+ */
+ @JvmName("asPolynomialVariable")
+ public fun V.asPolynomial(): P = number(this)
+
+ /**
+ * Returns sum of the variable represented as a monic monomial and the polynomial.
+ */
@JvmName("plusVariablePolynomial")
public operator fun V.plus(other: P): P
+ /**
+ * Returns difference between the variable represented as a monic monomial and the polynomial.
+ */
@JvmName("minusVariablePolynomial")
public operator fun V.minus(other: P): P
+ /**
+ * Returns product of the variable represented as a monic monomial and the polynomial.
+ */
@JvmName("timesVariablePolynomial")
public operator fun V.times(other: P): P
+ /**
+ * Returns sum of the polynomial and the variable represented as a monic monomial.
+ */
@JvmName("plusPolynomialVariable")
public operator fun P.plus(other: V): P
+ /**
+ * Returns difference between the polynomial and the variable represented as a monic monomial.
+ */
@JvmName("minusPolynomialVariable")
public operator fun P.minus(other: V): P
+ /**
+ * Returns product of the polynomial and the variable represented as a monic monomial.
+ */
@JvmName("timesPolynomialVariable")
public operator fun P.times(other: V): P
diff --git a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/RationalFunction.kt b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/RationalFunction.kt
index dfec126f3..01911f980 100644
--- a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/RationalFunction.kt
+++ b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/RationalFunction.kt
@@ -25,44 +25,44 @@ public interface RationalFunction<C, P: Polynomial<C>> {
* [C].
*
* @param C the type of constants. Polynomials have them as coefficients in their terms.
- * @param P the type of polynomials. Rational functions have them as numerators and denominators in them.
+ * @param P the type of polynomials. Rational functions have them as numerators and denominators.
* @param R the type of rational functions.
*/
@Suppress("INAPPLICABLE_JVM_NAME", "PARAMETER_NAME_CHANGED_ON_OVERRIDE") // FIXME: Waiting for KT-31420
public interface RationalFunctionalSpace<C, P: Polynomial<C>, R: RationalFunction<C, P>> : Ring<R> {
/**
- * Returns sum of the constant and the integer represented as constant (member of underlying ring).
+ * Returns sum of the constant and the integer represented as a constant (member of underlying ring).
*
* The operation is equivalent to adding [other] copies of unit of underlying ring to [this].
*/
public operator fun C.plus(other: Int): C
/**
- * Returns difference between the constant and the integer represented as constant (member of underlying ring).
+ * Returns difference between the constant and the integer represented as a constant (member of underlying ring).
*
* The operation is equivalent to subtraction [other] copies of unit of underlying ring from [this].
*/
public operator fun C.minus(other: Int): C
/**
- * Returns product of the constant and the integer represented as constant (member of underlying ring).
+ * Returns product of the constant and the integer represented as a constant (member of underlying ring).
*
* The operation is equivalent to sum of [other] copies of [this].
*/
public operator fun C.times(other: Int): C
/**
- * Returns sum of the integer represented as constant (member of underlying ring) and the constant.
+ * Returns sum of the integer represented as a constant (member of underlying ring) and the constant.
*
* The operation is equivalent to adding [this] copies of unit of underlying ring to [other].
*/
public operator fun Int.plus(other: C): C
/**
- * Returns difference between the integer represented as constant (member of underlying ring) and the constant.
+ * Returns difference between the integer represented as a constant (member of underlying ring) and the constant.
*
* The operation is equivalent to subtraction [this] copies of unit of underlying ring from [other].
*/
public operator fun Int.minus(other: C): C
/**
- * Returns product of the integer represented as constant (member of underlying ring) and the constant.
+ * Returns product of the integer represented as a constant (member of underlying ring) and the constant.
*
* The operation is equivalent to sum of [this] copies of [other].
*/
@@ -78,38 +78,38 @@ public interface RationalFunctionalSpace<C, P: Polynomial<C>, R: RationalFunctio
public fun Int.asConstant(): C = constantNumber(this)
/**
- * Returns sum of the constant and the integer represented as polynomial.
+ * Returns sum of the constant and the integer represented as a polynomial.
*
* The operation is equivalent to adding [other] copies of unit polynomial to [this].
*/
public operator fun P.plus(other: Int): P
/**
- * Returns difference between the constant and the integer represented as polynomial.
+ * Returns difference between the constant and the integer represented as a polynomial.
*
* The operation is equivalent to subtraction [other] copies of unit polynomial from [this].
*/
public operator fun P.minus(other: Int): P
/**
- * Returns product of the constant and the integer represented as polynomial.
+ * Returns product of the constant and the integer represented as a polynomial.
*
* The operation is equivalent to sum of [other] copies of [this].
*/
public operator fun P.times(other: Int): P
/**
- * Returns sum of the integer represented as polynomial and the constant.
+ * Returns sum of the integer represented as a polynomial and the constant.
*
* The operation is equivalent to adding [this] copies of unit polynomial to [other].
*/
public operator fun Int.plus(other: P): P
/**
- * Returns difference between the integer represented as polynomial and the constant.
+ * Returns difference between the integer represented as a polynomial and the constant.
*
* The operation is equivalent to subtraction [this] copies of unit polynomial from [other].
*/
public operator fun Int.minus(other: P): P
/**
- * Returns product of the integer represented as polynomial and the constant.
+ * Returns product of the integer represented as a polynomial and the constant.
*
* The operation is equivalent to sum of [this] copies of [other].
*/
@@ -125,25 +125,25 @@ public interface RationalFunctionalSpace<C, P: Polynomial<C>, R: RationalFunctio
public fun Int.asPolynomial(): P = polynomialNumber(this)
/**
- * Returns sum of the rational function and the integer represented as rational function.
+ * Returns sum of the rational function and the integer represented as a rational function.
*
* The operation is equivalent to adding [other] copies of unit polynomial to [this].
*/
public operator fun R.plus(other: Int): R = addMultipliedByDoubling(this, one, other)
/**
- * Returns difference between the rational function and the integer represented as rational function.
+ * Returns difference between the rational function and the integer represented as a rational function.
*
* The operation is equivalent to subtraction [other] copies of unit polynomial from [this].
*/
public operator fun R.minus(other: Int): R = addMultipliedByDoubling(this, one, -other)
/**
- * Returns product of the rational function and the integer represented as rational function.
+ * Returns product of the rational function and the integer represented as a rational function.
*
* The operation is equivalent to sum of [other] copies of [this].
*/
public operator fun R.times(other: Int): R = multiplyByDoubling(this, other)
/**
- * Returns quotient of the rational function and the integer represented as rational function.
+ * Returns quotient of the rational function and the integer represented as a rational function.
*
* The operation is equivalent to creating a new rational function by preserving numerator of [this] and
* multiplication denominator of [this] to [other].
@@ -151,25 +151,25 @@ public interface RationalFunctionalSpace<C, P: Polynomial<C>, R: RationalFunctio
public operator fun R.div(other: Int): R = this / multiplyByDoubling(one, other)
/**
- * Returns sum of the integer represented as rational function and the rational function.
+ * Returns sum of the integer represented as a rational function and the rational function.
*
* The operation is equivalent to adding [this] copies of unit polynomial to [other].
*/
public operator fun Int.plus(other: R): R = addMultipliedByDoubling(other, one, this)
/**
- * Returns difference between the integer represented as rational function and the rational function.
+ * Returns difference between the integer represented as a rational function and the rational function.
*
* The operation is equivalent to subtraction [this] copies of unit polynomial from [other].
*/
public operator fun Int.minus(other: R): R = addMultipliedByDoubling(-other, one, this)
/**
- * Returns product of the integer represented as rational function and the rational function.
+ * Returns product of the integer represented as a rational function and the rational function.
*
* The operation is equivalent to sum of [this] copies of [other].
*/
public operator fun Int.times(other: R): R = multiplyByDoubling(other, this)
/**
- * Returns quotient of the integer represented as rational function and the rational function.
+ * Returns quotient of the integer represented as a rational function and the rational function.
*
* The operation is equivalent to creating a new rational function which numerator is [this] times denominator of
* [other] and which denominator is [other]'s numerator.
@@ -232,28 +232,28 @@ public interface RationalFunctionalSpace<C, P: Polynomial<C>, R: RationalFunctio
public val constantOne: C
/**
- * Returns sum of the constant represented as polynomial and the polynomial.
+ * Returns sum of the constant represented as a polynomial and the polynomial.
*/
public operator fun C.plus(other: P): P
/**
- * Returns difference between the constant represented as polynomial and the polynomial.
+ * Returns difference between the constant represented as a polynomial and the polynomial.
*/
public operator fun C.minus(other: P): P
/**
- * Returns product of the constant represented as polynomial and the polynomial.
+ * Returns product of the constant represented as a polynomial and the polynomial.
*/
public operator fun C.times(other: P): P
/**
- * Returns sum of the constant represented as polynomial and the polynomial.
+ * Returns sum of the constant represented as a polynomial and the polynomial.
*/
public operator fun P.plus(other: C): P
/**
- * Returns difference between the constant represented as polynomial and the polynomial.
+ * Returns difference between the constant represented as a polynomial and the polynomial.
*/
public operator fun P.minus(other: C): P
/**
- * Returns product of the constant represented as polynomial and the polynomial.
+ * Returns product of the constant represented as a polynomial and the polynomial.
*/
public operator fun P.times(other: C): P
@@ -305,36 +305,36 @@ public interface RationalFunctionalSpace<C, P: Polynomial<C>, R: RationalFunctio
public val polynomialOne: P
/**
- * Returns sum of the constant represented as rational function and the rational function.
+ * Returns sum of the constant represented as a rational function and the rational function.
*/
public operator fun C.plus(other: R): R
/**
- * Returns difference between the constant represented as polynomial and the rational function.
+ * Returns difference between the constant represented as a polynomial and the rational function.
*/
public operator fun C.minus(other: R): R
/**
- * Returns product of the constant represented as polynomial and the rational function.
+ * Returns product of the constant represented as a polynomial and the rational function.
*/
public operator fun C.times(other: R): R
/**
- * Returns quotient of the constant represented as polynomial and the rational function.
+ * Returns quotient of the constant represented as a polynomial and the rational function.
*/
public operator fun C.div(other: R): R
/**
- * Returns sum of the rational function and the constant represented as rational function.
+ * Returns sum of the rational function and the constant represented as a rational function.
*/
public operator fun R.plus(other: C): R
/**
- * Returns difference between the rational function and the constant represented as rational function.
+ * Returns difference between the rational function and the constant represented as a rational function.
*/
public operator fun R.minus(other: C): R
/**
- * Returns product of the rational function and the constant represented as rational function.
+ * Returns product of the rational function and the constant represented as a rational function.
*/
public operator fun R.times(other: C): R
/**
- * Returns quotient of the rational function and the constant represented as rational function.
+ * Returns quotient of the rational function and the constant represented as a rational function.
*/
public operator fun R.div(other: C): R
@@ -348,36 +348,36 @@ public interface RationalFunctionalSpace<C, P: Polynomial<C>, R: RationalFunctio
public fun C.asRationalFunction(): R = number(this)
/**
- * Returns sum of the polynomial represented as rational function and the rational function.
+ * Returns sum of the polynomial represented as a rational function and the rational function.
*/
public operator fun P.plus(other: R): R
/**
- * Returns difference between the polynomial represented as polynomial and the rational function.
+ * Returns difference between the polynomial represented as a polynomial and the rational function.
*/
public operator fun P.minus(other: R): R
/**
- * Returns product of the polynomial represented as polynomial and the rational function.
+ * Returns product of the polynomial represented as a polynomial and the rational function.
*/
public operator fun P.times(other: R): R
/**
- * Returns quotient of the polynomial represented as polynomial and the rational function.
+ * Returns quotient of the polynomial represented as a polynomial and the rational function.
*/
public operator fun P.div(other: R): R
/**
- * Returns sum of the rational function and the polynomial represented as rational function.
+ * Returns sum of the rational function and the polynomial represented as a rational function.
*/
public operator fun R.plus(other: P): R
/**
- * Returns difference between the rational function and the polynomial represented as rational function.
+ * Returns difference between the rational function and the polynomial represented as a rational function.
*/
public operator fun R.minus(other: P): R
/**
- * Returns product of the rational function and the polynomial represented as rational function.
+ * Returns product of the rational function and the polynomial represented as a rational function.
*/
public operator fun R.times(other: P): R
/**
- * Returns quotient of the rational function and the polynomial represented as rational function.
+ * Returns quotient of the rational function and the polynomial represented as a rational function.
*/
public operator fun R.div(other: P): R
@@ -459,43 +459,51 @@ public interface RationalFunctionalSpace<C, P: Polynomial<C>, R: RationalFunctio
* @param A the type of algebraic structure (precisely, of ring) provided for constants.
*/
@Suppress("INAPPLICABLE_JVM_NAME") // FIXME: Waiting for KT-31420
-public interface RationalFunctionalSpaceOverRing<C, P: Polynomial<C>, R: RationalFunction<C, P>, A: Ring<C>> : RationalFunctionalSpace<C, P, R> {
+public interface RationalFunctionalSpaceOverRing<
+ C,
+ P: Polynomial<C>,
+ R: RationalFunction<C, P>,
+ A: Ring<C>
+ > : RationalFunctionalSpace<C, P, R> {
+ /**
+ * Underlying ring of constants. Its operations on constants are inherited by local operations on constants.
+ */
public val ring: A
/**
- * Returns sum of the constant and the integer represented as constant (member of underlying ring).
+ * Returns sum of the constant and the integer represented as a constant (member of underlying ring).
*
* The operation is equivalent to adding [other] copies of unit of underlying ring to [this].
*/
public override operator fun C.plus(other: Int): C = ring { addMultipliedByDoubling(this@plus, one, other) }
/**
- * Returns difference between the constant and the integer represented as constant (member of underlying ring).
+ * Returns difference between the constant and the integer represented as a constant (member of underlying ring).
*
* The operation is equivalent to subtraction [other] copies of unit of underlying ring from [this].
*/
public override operator fun C.minus(other: Int): C = ring { addMultipliedByDoubling(this@minus, one, -other) }
/**
- * Returns product of the constant and the integer represented as constant (member of underlying ring).
+ * Returns product of the constant and the integer represented as a constant (member of underlying ring).
*
* The operation is equivalent to sum of [other] copies of [this].
*/
public override operator fun C.times(other: Int): C = ring { multiplyByDoubling(this@times, other) }
/**
- * Returns sum of the integer represented as constant (member of underlying ring) and the constant.
+ * Returns sum of the integer represented as a constant (member of underlying ring) and the constant.
*
* The operation is equivalent to adding [this] copies of unit of underlying ring to [other].
*/
public override operator fun Int.plus(other: C): C = ring { addMultipliedByDoubling(other, one, this@plus) }
/**
- * Returns difference between the integer represented as constant (member of underlying ring) and the constant.
+ * Returns difference between the integer represented as a constant (member of underlying ring) and the constant.
*
* The operation is equivalent to subtraction [this] copies of unit of underlying ring from [other].
*/
public override operator fun Int.minus(other: C): C = ring { addMultipliedByDoubling(-other, one, this@minus) }
/**
- * Returns product of the integer represented as constant (member of underlying ring) and the constant.
+ * Returns product of the integer represented as a constant (member of underlying ring) and the constant.
*
* The operation is equivalent to sum of [this] copies of [other].
*/
@@ -560,41 +568,44 @@ public interface RationalFunctionalSpaceOverPolynomialSpace<
AP: PolynomialSpace<C, P>,
> : RationalFunctionalSpace<C, P, R> {
+ /**
+ * Underlying polynomial ring. Its polynomial operations are inherited by local polynomial operations.
+ */
public val polynomialRing: AP
/**
- * Returns sum of the constant and the integer represented as constant (member of underlying ring).
+ * Returns sum of the constant and the integer represented as a constant (member of underlying ring).
*
* The operation is equivalent to adding [other] copies of unit of underlying ring to [this].
*/
public override operator fun C.plus(other: Int): C = polynomialRing { this@plus + other }
/**
- * Returns difference between the constant and the integer represented as constant (member of underlying ring).
+ * Returns difference between the constant and the integer represented as a constant (member of underlying ring).
*
* The operation is equivalent to subtraction [other] copies of unit of underlying ring from [this].
*/
public override operator fun C.minus(other: Int): C = polynomialRing { this@minus - other }
/**
- * Returns product of the constant and the integer represented as constant (member of underlying ring).
+ * Returns product of the constant and the integer represented as a constant (member of underlying ring).
*
* The operation is equivalent to sum of [other] copies of [this].
*/
public override operator fun C.times(other: Int): C = polynomialRing { this@times * other }
/**
- * Returns sum of the integer represented as constant (member of underlying ring) and the constant.
+ * Returns sum of the integer represented as a constant (member of underlying ring) and the constant.
*
* The operation is equivalent to adding [this] copies of unit of underlying ring to [other].
*/
public override operator fun Int.plus(other: C): C = polynomialRing { this@plus + other }
/**
- * Returns difference between the integer represented as constant (member of underlying ring) and the constant.
+ * Returns difference between the integer represented as a constant (member of underlying ring) and the constant.
*
* The operation is equivalent to subtraction [this] copies of unit of underlying ring from [other].
*/
public override operator fun Int.minus(other: C): C = polynomialRing { this@minus - other }
/**
- * Returns product of the integer represented as constant (member of underlying ring) and the constant.
+ * Returns product of the integer represented as a constant (member of underlying ring) and the constant.
*
* The operation is equivalent to sum of [this] copies of [other].
*/
@@ -610,38 +621,38 @@ public interface RationalFunctionalSpaceOverPolynomialSpace<
override fun Int.asConstant(): C = polynomialRing { asConstant() }
/**
- * Returns sum of the constant and the integer represented as polynomial.
+ * Returns sum of the constant and the integer represented as a polynomial.
*
* The operation is equivalent to adding [other] copies of unit polynomial to [this].
*/
public override operator fun P.plus(other: Int): P = polynomialRing { this@plus + other }
/**
- * Returns difference between the constant and the integer represented as polynomial.
+ * Returns difference between the constant and the integer represented as a polynomial.
*
* The operation is equivalent to subtraction [other] copies of unit polynomial from [this].
*/
public override operator fun P.minus(other: Int): P = polynomialRing { this@minus - other }
/**
- * Returns product of the constant and the integer represented as polynomial.
+ * Returns product of the constant and the integer represented as a polynomial.
*
* The operation is equivalent to sum of [other] copies of [this].
*/
public override operator fun P.times(other: Int): P = polynomialRing { this@times * other }
/**
- * Returns sum of the integer represented as polynomial and the constant.
+ * Returns sum of the integer represented as a polynomial and the constant.
*
* The operation is equivalent to adding [this] copies of unit polynomial to [other].
*/
public override operator fun Int.plus(other: P): P = polynomialRing { this@plus + other }
/**
- * Returns difference between the integer represented as polynomial and the constant.
+ * Returns difference between the integer represented as a polynomial and the constant.
*
* The operation is equivalent to subtraction [this] copies of unit polynomial from [other].
*/
public override operator fun Int.minus(other: P): P = polynomialRing { this@minus - other }
/**
- * Returns product of the integer represented as polynomial and the constant.
+ * Returns product of the integer represented as a polynomial and the constant.
*
* The operation is equivalent to sum of [this] copies of [other].
*/
@@ -697,28 +708,28 @@ public interface RationalFunctionalSpaceOverPolynomialSpace<
public override val constantOne: C get() = polynomialRing.constantOne
/**
- * Returns sum of the constant represented as polynomial and the polynomial.
+ * Returns sum of the constant represented as a polynomial and the polynomial.
*/
public override operator fun C.plus(other: P): P = polynomialRing { this@plus + other }
/**
- * Returns difference between the constant represented as polynomial and the polynomial.
+ * Returns difference between the constant represented as a polynomial and the polynomial.
*/
public override operator fun C.minus(other: P): P = polynomialRing { this@minus - other }
/**
- * Returns product of the constant represented as polynomial and the polynomial.
+ * Returns product of the constant represented as a polynomial and the polynomial.
*/
public override operator fun C.times(other: P): P = polynomialRing { this@times * other }
/**
- * Returns sum of the constant represented as polynomial and the polynomial.
+ * Returns sum of the constant represented as a polynomial and the polynomial.
*/
public override operator fun P.plus(other: C): P = polynomialRing { this@plus + other }
/**
- * Returns difference between the constant represented as polynomial and the polynomial.
+ * Returns difference between the constant represented as a polynomial and the polynomial.
*/
public override operator fun P.minus(other: C): P = polynomialRing { this@minus - other }
/**
- * Returns product of the constant represented as polynomial and the polynomial.
+ * Returns product of the constant represented as a polynomial and the polynomial.
*/
public override operator fun P.times(other: C): P = polynomialRing { this@times * other }
@@ -774,7 +785,8 @@ public interface RationalFunctionalSpaceOverPolynomialSpace<
/**
* Abstraction of field of rational functions of type [R] with respect to polynomials of type [P] and constants of type
- * [C]. It also assumes that there is provided constructor
+ * [C]. It also assumes that there is provided constructor [constructRationalFunction] of rational functions from
+ * polynomial numerator and denominator.
*
* @param C the type of constants. Polynomials have them as coefficients in their terms.
* @param P the type of polynomials. Rational functions have them as numerators and denominators in them.
@@ -786,10 +798,14 @@ public abstract class PolynomialSpaceOfFractions<
P: Polynomial<C>,
R: RationalFunction<C, P>,
> : RationalFunctionalSpace<C, P, R> {
+
+ /**
+ * Constructor of rational functions (of type [R]) from numerator and denominator (of type [P]).
+ */
protected abstract fun constructRationalFunction(numerator: P, denominator: P = polynomialOne) : R
/**
- * Returns sum of the rational function and the integer represented as rational function.
+ * Returns sum of the rational function and the integer represented as a rational function.
*
* The operation is equivalent to adding [other] copies of unit polynomial to [this].
*/
@@ -799,7 +815,7 @@ public abstract class PolynomialSpaceOfFractions<
denominator
)
/**
- * Returns difference between the rational function and the integer represented as rational function.
+ * Returns difference between the rational function and the integer represented as a rational function.
*
* The operation is equivalent to subtraction [other] copies of unit polynomial from [this].
*/
@@ -809,7 +825,7 @@ public abstract class PolynomialSpaceOfFractions<
denominator
)
/**
- * Returns product of the rational function and the integer represented as rational function.
+ * Returns product of the rational function and the integer represented as a rational function.
*
* The operation is equivalent to sum of [other] copies of [this].
*/
@@ -818,7 +834,12 @@ public abstract class PolynomialSpaceOfFractions<
numerator * other,
denominator
)
-
+ /**
+ * Returns quotient of the rational function and the integer represented as a rational function.
+ *
+ * The operation is equivalent to creating a new rational function by preserving numerator of [this] and
+ * multiplication denominator of [this] to [other].
+ */
public override operator fun R.div(other: Int): R =
constructRationalFunction(
numerator,
@@ -826,7 +847,7 @@ public abstract class PolynomialSpaceOfFractions<
)
/**
- * Returns sum of the integer represented as rational function and the rational function.
+ * Returns sum of the integer represented as a rational function and the rational function.
*
* The operation is equivalent to adding [this] copies of unit polynomial to [other].
*/
@@ -836,7 +857,7 @@ public abstract class PolynomialSpaceOfFractions<
other.denominator
)
/**
- * Returns difference between the integer represented as rational function and the rational function.
+ * Returns difference between the integer represented as a rational function and the rational function.
*
* The operation is equivalent to subtraction [this] copies of unit polynomial from [other].
*/
@@ -846,7 +867,7 @@ public abstract class PolynomialSpaceOfFractions<
other.denominator
)
/**
- * Returns product of the integer represented as rational function and the rational function.
+ * Returns product of the integer represented as a rational function and the rational function.
*
* The operation is equivalent to sum of [this] copies of [other].
*/
@@ -855,7 +876,12 @@ public abstract class PolynomialSpaceOfFractions<
this * other.numerator,
other.denominator
)
-
+ /**
+ * Returns quotient of the integer represented as a rational function and the rational function.
+ *
+ * The operation is equivalent to creating a new rational function which numerator is [this] times denominator of
+ * [other] and which denominator is [other]'s numerator.
+ */
public override operator fun Int.div(other: R): R =
constructRationalFunction(
this * other.denominator,
@@ -873,7 +899,7 @@ public abstract class PolynomialSpaceOfFractions<
public override operator fun P.div(other: P): R = constructRationalFunction(this, other)
/**
- * Returns sum of the constant represented as rational function and the rational function.
+ * Returns sum of the constant represented as a rational function and the rational function.
*/
public override operator fun C.plus(other: R): R =
constructRationalFunction(
@@ -881,7 +907,7 @@ public abstract class PolynomialSpaceOfFractions<
other.denominator
)
/**
- * Returns difference between the constant represented as polynomial and the rational function.
+ * Returns difference between the constant represented as a polynomial and the rational function.
*/
public override operator fun C.minus(other: R): R =
constructRationalFunction(
@@ -889,14 +915,16 @@ public abstract class PolynomialSpaceOfFractions<
other.denominator
)
/**
- * Returns product of the constant represented as polynomial and the rational function.
+ * Returns product of the constant represented as a polynomial and the rational function.
*/
public override operator fun C.times(other: R): R =
constructRationalFunction(
this * other.numerator,
other.denominator
)
-
+ /**
+ * Returns quotient of the constant represented as a polynomial and the rational function.
+ */
public override operator fun C.div(other: R): R =
constructRationalFunction(
this * other.denominator,
@@ -904,7 +932,7 @@ public abstract class PolynomialSpaceOfFractions<
)
/**
- * Returns sum of the constant represented as rational function and the rational function.
+ * Returns sum of the constant represented as a rational function and the rational function.
*/
public override operator fun R.plus(other: C): R =
constructRationalFunction(
@@ -912,7 +940,7 @@ public abstract class PolynomialSpaceOfFractions<
denominator
)
/**
- * Returns difference between the constant represented as rational function and the rational function.
+ * Returns difference between the constant represented as a rational function and the rational function.
*/
public override operator fun R.minus(other: C): R =
constructRationalFunction(
@@ -920,14 +948,16 @@ public abstract class PolynomialSpaceOfFractions<
denominator
)
/**
- * Returns product of the constant represented as rational function and the rational function.
+ * Returns product of the constant represented as a rational function and the rational function.
*/
public override operator fun R.times(other: C): R =
constructRationalFunction(
numerator * other,
denominator
)
-
+ /**
+ * Returns quotient of the rational function and the constant represented as a rational function.
+ */
public override operator fun R.div(other: C): R =
constructRationalFunction(
numerator,
@@ -940,7 +970,7 @@ public abstract class PolynomialSpaceOfFractions<
public override fun number(value: C): R = constructRationalFunction(polynomialNumber(value))
/**
- * Returns sum of the polynomial represented as rational function and the rational function.
+ * Returns sum of the polynomial represented as a rational function and the rational function.
*/
public override operator fun P.plus(other: R): R =
constructRationalFunction(
@@ -948,7 +978,7 @@ public abstract class PolynomialSpaceOfFractions<
other.denominator
)
/**
- * Returns difference between the polynomial represented as polynomial and the rational function.
+ * Returns difference between the polynomial represented as a polynomial and the rational function.
*/
public override operator fun P.minus(other: R): R =
constructRationalFunction(
@@ -956,14 +986,16 @@ public abstract class PolynomialSpaceOfFractions<
other.denominator
)
/**
- * Returns product of the polynomial represented as polynomial and the rational function.
+ * Returns product of the polynomial represented as a polynomial and the rational function.
*/
public override operator fun P.times(other: R): R =
constructRationalFunction(
this * other.numerator,
other.denominator
)
-
+ /**
+ * Returns quotient of the polynomial represented as a polynomial and the rational function.
+ */
public override operator fun P.div(other: R): R =
constructRationalFunction(
this * other.denominator,
@@ -971,7 +1003,7 @@ public abstract class PolynomialSpaceOfFractions<
)
/**
- * Returns sum of the polynomial represented as rational function and the rational function.
+ * Returns sum of the polynomial represented as a rational function and the rational function.
*/
public override operator fun R.plus(other: P): R =
constructRationalFunction(
@@ -979,7 +1011,7 @@ public abstract class PolynomialSpaceOfFractions<
denominator
)
/**
- * Returns difference between the polynomial represented as rational function and the rational function.
+ * Returns difference between the polynomial represented as a rational function and the rational function.
*/
public override operator fun R.minus(other: P): R =
constructRationalFunction(
@@ -987,14 +1019,16 @@ public abstract class PolynomialSpaceOfFractions<
denominator
)
/**
- * Returns product of the polynomial represented as rational function and the rational function.
+ * Returns product of the polynomial represented as a rational function and the rational function.
*/
public override operator fun R.times(other: P): R =
constructRationalFunction(
numerator * other,
denominator
)
-
+ /**
+ * Returns quotient of the rational function and the polynomial represented as a rational function.
+ */
public override operator fun R.div(other: P): R =
constructRationalFunction(
numerator,
@@ -1034,7 +1068,9 @@ public abstract class PolynomialSpaceOfFractions<
numerator * other.numerator,
denominator * other.denominator
)
-
+ /**
+ * Returns quotient of the rational functions.
+ */
public override operator fun R.div(other: R): R =
constructRationalFunction(
numerator * other.denominator,
@@ -1044,14 +1080,23 @@ public abstract class PolynomialSpaceOfFractions<
/**
* Instance of zero rational function (zero of the rational functions ring).
*/
- public override val zero: R get() = constructRationalFunction(polynomialZero)
+ public override val zero: R by lazy { constructRationalFunction(polynomialZero) }
/**
* Instance of unit polynomial (unit of the rational functions ring).
*/
- public override val one: R get() = constructRationalFunction(polynomialOne)
+ public override val one: R by lazy { constructRationalFunction(polynomialOne) }
}
+/**
+ * Abstraction of field of rational functions of type [R] with respect to polynomials of type [P] of variables of type
+ * [V] and over ring of constants of type [C].
+ *
+ * @param C the type of constants. Polynomials have them as coefficients in their terms.
+ * @param V the type of variables. Polynomials have them in representations of terms.
+ * @param P the type of polynomials. Rational functions have them as numerators and denominators in them.
+ * @param R the type of rational functions.
+ */
@Suppress("INAPPLICABLE_JVM_NAME") // FIXME: Waiting for KT-31420
public interface MultivariateRationalFunctionalSpace<
C,
@@ -1059,70 +1104,179 @@ public interface MultivariateRationalFunctionalSpace<
P: Polynomial<C>,
R: RationalFunction<C, P>
>: RationalFunctionalSpace<C, P, R> {
+ /**
+ * Returns sum of the variable represented as a monic monomial and the integer represented as a constant polynomial.
+ */
@JvmName("plusVariableInt")
public operator fun V.plus(other: Int): P
+ /**
+ * Returns difference between the variable represented as a monic monomial and the integer represented as a constant polynomial.
+ */
@JvmName("minusVariableInt")
public operator fun V.minus(other: Int): P
+ /**
+ * Returns product of the variable represented as a monic monomial and the integer represented as a constant polynomial.
+ */
@JvmName("timesVariableInt")
public operator fun V.times(other: Int): P
+ /**
+ * Returns sum of the integer represented as a constant polynomial and the variable represented as a monic monomial.
+ */
@JvmName("plusIntVariable")
public operator fun Int.plus(other: V): P
+ /**
+ * Returns difference between the integer represented as a constant polynomial and the variable represented as a monic monomial.
+ */
@JvmName("minusIntVariable")
public operator fun Int.minus(other: V): P
+ /**
+ * Returns product of the integer represented as a constant polynomial and the variable represented as a monic monomial.
+ */
@JvmName("timesIntVariable")
public operator fun Int.times(other: V): P
- @JvmName("plusConstantVariable")
- public operator fun C.plus(other: V): P
- @JvmName("minusConstantVariable")
- public operator fun C.minus(other: V): P
- @JvmName("timesConstantVariable")
- public operator fun C.times(other: V): P
-
+ /**
+ * Returns sum of the variable represented as a monic monomial and the constant represented as a constant polynomial.
+ */
@JvmName("plusVariableConstant")
public operator fun V.plus(other: C): P
+ /**
+ * Returns difference between the variable represented as a monic monomial and the constant represented as a constant polynomial.
+ */
@JvmName("minusVariableConstant")
public operator fun V.minus(other: C): P
+ /**
+ * Returns product of the variable represented as a monic monomial and the constant represented as a constant polynomial.
+ */
@JvmName("timesVariableConstant")
public operator fun V.times(other: C): P
+ /**
+ * Returns sum of the constant represented as a constant polynomial and the variable represented as a monic monomial.
+ */
+ @JvmName("plusConstantVariable")
+ public operator fun C.plus(other: V): P
+ /**
+ * Returns difference between the constant represented as a constant polynomial and the variable represented as a monic monomial.
+ */
+ @JvmName("minusConstantVariable")
+ public operator fun C.minus(other: V): P
+ /**
+ * Returns product of the constant represented as a constant polynomial and the variable represented as a monic monomial.
+ */
+ @JvmName("timesConstantVariable")
+ public operator fun C.times(other: V): P
+
+ /**
+ * Represents the variable as a monic monomial.
+ */
@JvmName("unaryPlusVariable")
public operator fun V.unaryPlus(): P
+ /**
+ * Returns negation of representation of the variable as a monic monomial.
+ */
@JvmName("unaryMinusVariable")
public operator fun V.unaryMinus(): P
+ /**
+ * Returns sum of the variables represented as monic monomials.
+ */
@JvmName("plusVariableVariable")
public operator fun V.plus(other: V): P
+ /**
+ * Returns difference between the variables represented as monic monomials.
+ */
@JvmName("minusVariableVariable")
public operator fun V.minus(other: V): P
+ /**
+ * Returns product of the variables represented as monic monomials.
+ */
@JvmName("timesVariableVariable")
public operator fun V.times(other: V): P
+ /**
+ * Represents the [variable] as a monic monomial.
+ */
+ @JvmName("polynomialNumberVariable")
+ public fun polynomialNumber(variable: V): P = +variable
+ /**
+ * Represents the variable as a monic monomial.
+ */
+ @JvmName("asPolynomialVariable")
+ public fun V.asPolynomial(): P = polynomialNumber(this)
+
+ /**
+ * Represents the [variable] as a rational function.
+ */
+ @JvmName("numberVariable")
+ public fun number(variable: V): R = number(polynomialNumber(variable))
+ /**
+ * Represents the variable as a rational function.
+ */
+ @JvmName("asRationalFunctionVariable")
+ public fun V.asRationalFunction(): R = number(this)
+
+ /**
+ * Returns sum of the variable represented as a monic monomial and the polynomial.
+ */
@JvmName("plusVariablePolynomial")
public operator fun V.plus(other: P): P
+ /**
+ * Returns difference between the variable represented as a monic monomial and the polynomial.
+ */
@JvmName("minusVariablePolynomial")
public operator fun V.minus(other: P): P
+ /**
+ * Returns product of the variable represented as a monic monomial and the polynomial.
+ */
@JvmName("timesVariablePolynomial")
public operator fun V.times(other: P): P
+ /**
+ * Returns sum of the polynomial and the variable represented as a monic monomial.
+ */
@JvmName("plusPolynomialVariable")
public operator fun P.plus(other: V): P
+ /**
+ * Returns difference between the polynomial and the variable represented as a monic monomial.
+ */
@JvmName("minusPolynomialVariable")
public operator fun P.minus(other: V): P
+ /**
+ * Returns product of the polynomial and the variable represented as a monic monomial.
+ */
@JvmName("timesPolynomialVariable")
public operator fun P.times(other: V): P
+ /**
+ * Returns sum of the variable represented as a rational function and the rational function.
+ */
@JvmName("plusVariableRational")
public operator fun V.plus(other: R): R
+ /**
+ * Returns difference between the variable represented as a rational function and the rational function.
+ */
@JvmName("minusVariableRational")
public operator fun V.minus(other: R): R
+ /**
+ * Returns product of the variable represented as a rational function and the rational function.
+ */
@JvmName("timesVariableRational")
public operator fun V.times(other: R): R
+ /**
+ * Returns sum of the rational function and the variable represented as a rational function.
+ */
@JvmName("plusRationalVariable")
public operator fun R.plus(other: V): R
+ /**
+ * Returns difference between the rational function and the variable represented as a rational function.
+ */
@JvmName("minusRationalVariable")
public operator fun R.minus(other: V): R
+ /**
+ * Returns product of the rational function and the variable represented as a rational function.
+ */
@JvmName("timesRationalVariable")
public operator fun R.times(other: V): R
@@ -1161,22 +1315,17 @@ public interface MultivariateRationalFunctionalSpace<
public val R.countOfVariables: Int get() = variables.size
}
-public interface MultivariateRationalFunctionalSpaceOverRing<
- C,
- V,
- P: Polynomial<C>,
- R: RationalFunction<C, P>,
- A: Ring<C>
- > : RationalFunctionalSpaceOverRing<C, P, R, A>, MultivariateRationalFunctionalSpace<C, V, P, R>
-
-public interface MultivariateRationalFunctionalSpaceOverPolynomialSpace<
- C,
- V,
- P: Polynomial<C>,
- R: RationalFunction<C, P>,
- AP: PolynomialSpace<C, P>,
- > : RationalFunctionalSpaceOverPolynomialSpace<C, P, R, AP>, MultivariateRationalFunctionalSpace<C, V, P, R>
-
+/**
+ * Abstraction of field of rational functions of type [R] with respect to polynomials of type [P] of variables of type
+ * [V] and over ring of constants of type [C]. It also assumes that there is provided [polynomialRing] (of type [AP]),
+ * that provides constant-, variable- and polynomial-wise operations.
+ *
+ * @param C the type of constants. Polynomials have them as coefficients in their terms.
+ * @param V the type of variables. Polynomials have them in representations of terms.
+ * @param P the type of polynomials. Rational functions have them as numerators and denominators in them.
+ * @param R the type of rational functions.
+ * @param AP the type of algebraic structure (precisely, of ring) provided for polynomials.
+ */
@Suppress("INAPPLICABLE_JVM_NAME") // FIXME: Waiting for KT-31420
public interface MultivariateRationalFunctionalSpaceOverMultivariatePolynomialSpace<
C,
@@ -1184,57 +1333,137 @@ public interface MultivariateRationalFunctionalSpaceOverMultivariatePolynomialSp
P: Polynomial<C>,
R: RationalFunction<C, P>,
AP: MultivariatePolynomialSpace<C, V, P>,
- > : MultivariateRationalFunctionalSpaceOverPolynomialSpace<C, V, P, R, AP> {
+ > : RationalFunctionalSpaceOverPolynomialSpace<C, P, R, AP>, MultivariateRationalFunctionalSpace<C, V, P, R> {
+ /**
+ * Returns sum of the variable represented as a monic monomial and the integer represented as a constant polynomial.
+ */
@JvmName("plusVariableInt")
public override operator fun V.plus(other: Int): P = polynomialRing { this@plus + other }
+ /**
+ * Returns difference between the variable represented as a monic monomial and the integer represented as a constant polynomial.
+ */
@JvmName("minusVariableInt")
public override operator fun V.minus(other: Int): P = polynomialRing { this@minus - other }
+ /**
+ * Returns product of the variable represented as a monic monomial and the integer represented as a constant polynomial.
+ */
@JvmName("timesVariableInt")
public override operator fun V.times(other: Int): P = polynomialRing { this@times * other }
+ /**
+ * Returns sum of the integer represented as a constant polynomial and the variable represented as a monic monomial.
+ */
@JvmName("plusIntVariable")
public override operator fun Int.plus(other: V): P = polynomialRing { this@plus + other }
+ /**
+ * Returns difference between the integer represented as a constant polynomial and the variable represented as a monic monomial.
+ */
@JvmName("minusIntVariable")
public override operator fun Int.minus(other: V): P = polynomialRing { this@minus - other }
+ /**
+ * Returns product of the integer represented as a constant polynomial and the variable represented as a monic monomial.
+ */
@JvmName("timesIntVariable")
public override operator fun Int.times(other: V): P = polynomialRing { this@times * other }
- @JvmName("plusConstantVariable")
- public override operator fun C.plus(other: V): P = polynomialRing { this@plus + other }
- @JvmName("minusConstantVariable")
- public override operator fun C.minus(other: V): P = polynomialRing { this@minus - other }
- @JvmName("timesConstantVariable")
- public override operator fun C.times(other: V): P = polynomialRing { this@times * other }
-
+ /**
+ * Returns sum of the variable represented as a monic monomial and the constant represented as a constant polynomial.
+ */
@JvmName("plusVariableConstant")
public override operator fun V.plus(other: C): P = polynomialRing { this@plus + other }
+ /**
+ * Returns difference between the variable represented as a monic monomial and the constant represented as a constant polynomial.
+ */
@JvmName("minusVariableConstant")
public override operator fun V.minus(other: C): P = polynomialRing { this@minus - other }
+ /**
+ * Returns product of the variable represented as a monic monomial and the constant represented as a constant polynomial.
+ */
@JvmName("timesVariableConstant")
public override operator fun V.times(other: C): P = polynomialRing { this@times * other }
+ /**
+ * Returns sum of the constant represented as a constant polynomial and the variable represented as a monic monomial.
+ */
+ @JvmName("plusConstantVariable")
+ public override operator fun C.plus(other: V): P = polynomialRing { this@plus + other }
+ /**
+ * Returns difference between the constant represented as a constant polynomial and the variable represented as a monic monomial.
+ */
+ @JvmName("minusConstantVariable")
+ public override operator fun C.minus(other: V): P = polynomialRing { this@minus - other }
+ /**
+ * Returns product of the constant represented as a constant polynomial and the variable represented as a monic monomial.
+ */
+ @JvmName("timesConstantVariable")
+ public override operator fun C.times(other: V): P = polynomialRing { this@times * other }
+
+ /**
+ * Represents the variable as a monic monomial.
+ */
@JvmName("unaryPlusVariable")
public override operator fun V.unaryPlus(): P = polynomialRing { +this@unaryPlus }
+ /**
+ * Returns negation of representation of the variable as a monic monomial.
+ */
@JvmName("unaryMinusVariable")
public override operator fun V.unaryMinus(): P = polynomialRing { -this@unaryMinus }
+ /**
+ * Returns sum of the variables represented as monic monomials.
+ */
@JvmName("plusVariableVariable")
public override operator fun V.plus(other: V): P = polynomialRing { this@plus + other }
+ /**
+ * Returns difference between the variables represented as monic monomials.
+ */
@JvmName("minusVariableVariable")
public override operator fun V.minus(other: V): P = polynomialRing { this@minus - other }
+ /**
+ * Returns product of the variables represented as monic monomials.
+ */
@JvmName("timesVariableVariable")
public override operator fun V.times(other: V): P = polynomialRing { this@times * other }
+ /**
+ * Represents the [variable] as a monic monomial.
+ */
+ @JvmName("polynomialNumberVariable")
+ public override fun polynomialNumber(variable: V): P = polynomialRing { number(variable) }
+ /**
+ * Represents the variable as a monic monomial.
+ */
+ @JvmName("asPolynomialVariable")
+ public override fun V.asPolynomial(): P = polynomialRing { this@asPolynomial.asPolynomial() }
+
+ /**
+ * Returns sum of the variable represented as a monic monomial and the polynomial.
+ */
@JvmName("plusVariablePolynomial")
public override operator fun V.plus(other: P): P = polynomialRing { this@plus + other }
+ /**
+ * Returns difference between the variable represented as a monic monomial and the polynomial.
+ */
@JvmName("minusVariablePolynomial")
public override operator fun V.minus(other: P): P = polynomialRing { this@minus - other }
+ /**
+ * Returns product of the variable represented as a monic monomial and the polynomial.
+ */
@JvmName("timesVariablePolynomial")
public override operator fun V.times(other: P): P = polynomialRing { this@times * other }
+ /**
+ * Returns sum of the polynomial and the variable represented as a monic monomial.
+ */
@JvmName("plusPolynomialVariable")
public override operator fun P.plus(other: V): P = polynomialRing { this@plus + other }
+ /**
+ * Returns difference between the polynomial and the variable represented as a monic monomial.
+ */
@JvmName("minusPolynomialVariable")
public override operator fun P.minus(other: V): P = polynomialRing { this@minus - other }
+ /**
+ * Returns product of the polynomial and the variable represented as a monic monomial.
+ */
@JvmName("timesPolynomialVariable")
public override operator fun P.times(other: V): P = polynomialRing { this@times * other }
@@ -1264,6 +1493,16 @@ public interface MultivariateRationalFunctionalSpaceOverMultivariatePolynomialSp
public override val P.countOfVariables: Int get() = polynomialRing { countOfVariables }
}
+/**
+ * Abstraction of field of rational functions of type [R] with respect to polynomials of type [P] of variables of type
+ * [V] and over ring of constants of type [C]. It also assumes that there is provided constructor
+ * [constructRationalFunction] of rational functions from polynomial numerator and denominator.
+ *
+ * @param C the type of constants. Polynomials have them as coefficients in their terms.
+ * @param V the type of variables. Polynomials have them in representations of terms.
+ * @param P the type of polynomials. Rational functions have them as numerators and denominators in them.
+ * @param R the type of rational functions.
+ */
@Suppress("INAPPLICABLE_JVM_NAME") // FIXME: Waiting for KT-31420
public abstract class MultivariatePolynomialSpaceOfFractions<
C,
@@ -1271,18 +1510,27 @@ public abstract class MultivariatePolynomialSpaceOfFractions<
P: Polynomial<C>,
R: RationalFunction<C, P>,
> : MultivariateRationalFunctionalSpace<C, V, P, R>, PolynomialSpaceOfFractions<C, P, R>() {
+ /**
+ * Returns sum of the variable represented as a rational function and the rational function.
+ */
@JvmName("plusVariableRational")
public override operator fun V.plus(other: R): R =
constructRationalFunction(
this * other.denominator + other.numerator,
other.denominator
)
+ /**
+ * Returns difference between the variable represented as a rational function and the rational function.
+ */
@JvmName("minusVariableRational")
public override operator fun V.minus(other: R): R =
constructRationalFunction(
this * other.denominator - other.numerator,
other.denominator
)
+ /**
+ * Returns product of the variable represented as a rational function and the rational function.
+ */
@JvmName("timesVariableRational")
public override operator fun V.times(other: R): R =
constructRationalFunction(
@@ -1290,18 +1538,27 @@ public abstract class MultivariatePolynomialSpaceOfFractions<
other.denominator
)
+ /**
+ * Returns sum of the rational function and the variable represented as a rational function.
+ */
@JvmName("plusRationalVariable")
public override operator fun R.plus(other: V): R =
constructRationalFunction(
numerator + denominator * other,
denominator
)
+ /**
+ * Returns difference between the rational function and the variable represented as a rational function.
+ */
@JvmName("minusRationalVariable")
public override operator fun R.minus(other: V): R =
constructRationalFunction(
numerator - denominator * other,
denominator
)
+ /**
+ * Returns product of the rational function and the variable represented as a rational function.
+ */
@JvmName("timesRationalVariable")
public override operator fun R.times(other: V): R =
constructRationalFunction(
diff --git a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/labeledConstructors.kt b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/labeledConstructors.kt
deleted file mode 100644
index e81a9388e..000000000
--- a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/labeledConstructors.kt
+++ /dev/null
@@ -1,203 +0,0 @@
-/*
- * Copyright 2018-2021 KMath contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package space.kscience.kmath.functions
-
-import space.kscience.kmath.expressions.Symbol
-import space.kscience.kmath.misc.UnstableKMathAPI
-import space.kscience.kmath.operations.Ring
-
-
-/**
- * Returns the same degrees' description of the monomial, but without zero degrees.
- */
-internal fun Map<Symbol, UInt>.cleanUp() = filterValues { it > 0U }
-
-// Waiting for context receivers :( FIXME: Replace with context receivers when they will be available
-
-@Suppress("FunctionName", "NOTHING_TO_INLINE")
-internal inline fun <C, A: Ring<C>> LabeledPolynomialSpace<C, A>.LabeledPolynomial(coefs: Map<Map<Symbol, UInt>, C>, toCheckInput: Boolean = true) : LabeledPolynomial<C> = ring.LabeledPolynomial(coefs, toCheckInput)
-@Suppress("FunctionName", "NOTHING_TO_INLINE")
-internal inline fun <C, A: Ring<C>> LabeledRationalFunctionSpace<C, A>.LabeledPolynomial(coefs: Map<Map<Symbol, UInt>, C>, toCheckInput: Boolean = true) : LabeledPolynomial<C> = ring.LabeledPolynomial(coefs, toCheckInput)
-@Suppress("FunctionName")
-internal fun <C, A: Ring<C>> A.LabeledPolynomial(coefs: Map<Map<Symbol, UInt>, C>, toCheckInput: Boolean = true) : LabeledPolynomial<C> {
- if (!toCheckInput) return LabeledPolynomial<C>(coefs)
-
- val fixedCoefs = LinkedHashMap<Map<Symbol, UInt>, C>(coefs.size)
-
- for (entry in coefs) {
- val key = entry.key.cleanUp()
- val value = entry.value
- fixedCoefs[key] = if (key in fixedCoefs) fixedCoefs[key]!! + value else value
- }
-
- return LabeledPolynomial<C>(fixedCoefs)
-}
-
-@Suppress("FunctionName", "NOTHING_TO_INLINE")
-internal inline fun <C, A: Ring<C>> LabeledPolynomialSpace<C, A>.LabeledPolynomial(pairs: Collection<Pair<Map<Symbol, UInt>, C>>, toCheckInput: Boolean = true) : LabeledPolynomial<C> = ring.LabeledPolynomial(pairs, toCheckInput)
-@Suppress("FunctionName", "NOTHING_TO_INLINE")
-internal inline fun <C, A: Ring<C>> LabeledRationalFunctionSpace<C, A>.LabeledPolynomial(pairs: Collection<Pair<Map<Symbol, UInt>, C>>, toCheckInput: Boolean = true) : LabeledPolynomial<C> = ring.LabeledPolynomial(pairs, toCheckInput)
-@Suppress("FunctionName")
-internal fun <C, A: Ring<C>> A.LabeledPolynomial(pairs: Collection<Pair<Map<Symbol, UInt>, C>>, toCheckInput: Boolean = true) : LabeledPolynomial<C> {
- if (!toCheckInput) return LabeledPolynomial<C>(pairs.toMap())
-
- val fixedCoefs = LinkedHashMap<Map<Symbol, UInt>, C>(pairs.size)
-
- for (entry in pairs) {
- val key = entry.first.cleanUp()
- val value = entry.second
- fixedCoefs[key] = if (key in fixedCoefs) fixedCoefs[key]!! + value else value
- }
-
- return LabeledPolynomial<C>(fixedCoefs)
-}
-
-@Suppress("FunctionName", "NOTHING_TO_INLINE")
-internal inline fun <C, A: Ring<C>> LabeledPolynomialSpace<C, A>.LabeledPolynomial(vararg pairs: Pair<Map<Symbol, UInt>, C>, toCheckInput: Boolean = true) : LabeledPolynomial<C> = ring.LabeledPolynomial(pairs = pairs, toCheckInput = toCheckInput)
-@Suppress("FunctionName", "NOTHING_TO_INLINE")
-internal inline fun <C, A: Ring<C>> LabeledRationalFunctionSpace<C, A>.LabeledPolynomial(vararg pairs: Pair<Map<Symbol, UInt>, C>, toCheckInput: Boolean = true) : LabeledPolynomial<C> = ring.LabeledPolynomial(pairs = pairs, toCheckInput = toCheckInput)
-@Suppress("FunctionName")
-internal fun <C, A: Ring<C>> A.LabeledPolynomial(vararg pairs: Pair<Map<Symbol, UInt>, C>, toCheckInput: Boolean = true) : LabeledPolynomial<C> {
- if (!toCheckInput) return LabeledPolynomial<C>(pairs.toMap())
-
- val fixedCoefs = LinkedHashMap<Map<Symbol, UInt>, C>(pairs.size)
-
- for (entry in pairs) {
- val key = entry.first.cleanUp()
- val value = entry.second
- fixedCoefs[key] = if (key in fixedCoefs) fixedCoefs[key]!! + value else value
- }
-
- return LabeledPolynomial<C>(fixedCoefs)
-}
-
-@Suppress("FunctionName")
-public fun <C, A: Ring<C>> A.LabeledPolynomial(coefs: Map<Map<Symbol, UInt>, C>) : LabeledPolynomial<C> = LabeledPolynomial(coefs, toCheckInput = true)
-@Suppress("FunctionName")
-public fun <C, A: Ring<C>> LabeledPolynomialSpace<C, A>.LabeledPolynomial(coefs: Map<Map<Symbol, UInt>, C>) : LabeledPolynomial<C> = LabeledPolynomial(coefs, toCheckInput = true)
-@Suppress("FunctionName")
-public fun <C, A: Ring<C>> LabeledRationalFunctionSpace<C, A>.LabeledPolynomial(coefs: Map<Map<Symbol, UInt>, C>) : LabeledPolynomial<C> = LabeledPolynomial(coefs, toCheckInput = true)
-
-@Suppress("FunctionName")
-public fun <C, A: Ring<C>> A.LabeledPolynomial(pairs: Collection<Pair<Map<Symbol, UInt>, C>>) : LabeledPolynomial<C> = LabeledPolynomial(pairs, toCheckInput = true)
-@Suppress("FunctionName")
-public fun <C, A: Ring<C>> LabeledPolynomialSpace<C, A>.LabeledPolynomial(pairs: Collection<Pair<Map<Symbol, UInt>, C>>) : LabeledPolynomial<C> = LabeledPolynomial(pairs, toCheckInput = true)
-@Suppress("FunctionName")
-public fun <C, A: Ring<C>> LabeledRationalFunctionSpace<C, A>.LabeledPolynomial(pairs: Collection<Pair<Map<Symbol, UInt>, C>>) : LabeledPolynomial<C> = LabeledPolynomial(pairs, toCheckInput = true)
-
-@Suppress("FunctionName")
-public fun <C, A: Ring<C>> A.LabeledPolynomial(vararg pairs: Pair<Map<Symbol, UInt>, C>) : LabeledPolynomial<C> = LabeledPolynomial(*pairs, toCheckInput = true)
-@Suppress("FunctionName")
-public fun <C, A: Ring<C>> LabeledPolynomialSpace<C, A>.LabeledPolynomial(vararg pairs: Pair<Map<Symbol, UInt>, C>) : LabeledPolynomial<C> = LabeledPolynomial(*pairs, toCheckInput = true)
-@Suppress("FunctionName")
-public fun <C, A: Ring<C>> LabeledRationalFunctionSpace<C, A>.LabeledPolynomial(vararg pairs: Pair<Map<Symbol, UInt>, C>) : LabeledPolynomial<C> = LabeledPolynomial(*pairs, toCheckInput = true)
-
-//context(A)
-//public fun <C, A: Ring<C>> Symbol.asLabeledPolynomial() : LabeledPolynomial<C> = LabeledPolynomial<C>(mapOf(mapOf(this to 1u) to one))
-//context(LabeledPolynomialSpace<C, A>)
-//public fun <C, A: Ring<C>> Symbol.asLabeledPolynomial() : LabeledPolynomial<C> = LabeledPolynomial<C>(mapOf(mapOf(this to 1u) to constantOne))
-//context(LabeledRationalFunctionSpace<C, A>)
-//public fun <C, A: Ring<C>> Symbol.asLabeledPolynomial() : LabeledPolynomial<C> = LabeledPolynomial<C>(mapOf(mapOf(this to 1u) to constantOne))
-
-public fun <C> C.asLabeledPolynomial() : LabeledPolynomial<C> = LabeledPolynomial<C>(mapOf(emptyMap<Symbol, UInt>() to this))
-
-@DslMarker
-@UnstableKMathAPI
-internal annotation class LabeledPolynomialConstructorDSL
-
-@UnstableKMathAPI
-@LabeledPolynomialConstructorDSL
-public class LabeledPolynomialTermSignatureBuilder {
- private val signature: MutableMap<Symbol, UInt> = LinkedHashMap()
- public fun build(): Map<Symbol, UInt> = signature
- public infix fun Symbol.inPowerOf(deg: UInt) {
- signature[this] = deg
- }
- @Suppress("NOTHING_TO_INLINE")
- public inline infix fun Symbol.pow(deg: UInt): Unit = this inPowerOf deg
- @Suppress("NOTHING_TO_INLINE")
- public inline infix fun Symbol.`in`(deg: UInt): Unit = this inPowerOf deg
- @Suppress("NOTHING_TO_INLINE")
- public inline infix fun Symbol.of(deg: UInt): Unit = this inPowerOf deg
-}
-
-@UnstableKMathAPI
-public class LabeledPolynomialBuilder<C>(private val zero: C, private val add: (C, C) -> C, capacity: Int = 0) {
- private val coefficients: MutableMap<Map<Symbol, UInt>, C> = LinkedHashMap(capacity)
- public fun build(): LabeledPolynomial<C> = LabeledPolynomial<C>(coefficients)
- public operator fun C.invoke(block: LabeledPolynomialTermSignatureBuilder.() -> Unit) {
- val signature = LabeledPolynomialTermSignatureBuilder().apply(block).build()
- coefficients[signature] = add(coefficients.getOrElse(signature) { zero }, this@invoke)
- }
- @Suppress("NOTHING_TO_INLINE")
- public inline infix fun C.with(noinline block: LabeledPolynomialTermSignatureBuilder.() -> Unit): Unit = this.invoke(block)
- @Suppress("NOTHING_TO_INLINE")
- public inline infix fun (LabeledPolynomialTermSignatureBuilder.() -> Unit).with(coef: C): Unit = coef.invoke(this)
- @Suppress("NOTHING_TO_INLINE")
- public infix fun sig(block: LabeledPolynomialTermSignatureBuilder.() -> Unit): LabeledPolynomialTermSignatureBuilder.() -> Unit = block
-}
-
-// Waiting for context receivers :( FIXME: Replace with context receivers when they will be available
-
-@UnstableKMathAPI
-@LabeledPolynomialConstructorDSL
-@Suppress("FunctionName")
-public inline fun <C, A: Ring<C>> A.LabeledPolynomial(block: LabeledPolynomialBuilder<C>.() -> Unit) : LabeledPolynomial<C> = LabeledPolynomialBuilder(zero, ::add).apply(block).build()
-@UnstableKMathAPI
-@LabeledPolynomialConstructorDSL
-@Suppress("FunctionName")
-public inline fun <C, A: Ring<C>> A.LabeledPolynomial(capacity: Int, block: LabeledPolynomialBuilder<C>.() -> Unit) : LabeledPolynomial<C> = LabeledPolynomialBuilder(zero, ::add, capacity).apply(block).build()
-@UnstableKMathAPI
-@LabeledPolynomialConstructorDSL
-@Suppress("FunctionName")
-public inline fun <C, A: Ring<C>> LabeledPolynomialSpace<C, A>.LabeledPolynomial(block: LabeledPolynomialBuilder<C>.() -> Unit) : LabeledPolynomial<C> = LabeledPolynomialBuilder(constantZero, { left: C, right: C -> left + right}).apply(block).build()
-@UnstableKMathAPI
-@LabeledPolynomialConstructorDSL
-@Suppress("FunctionName")
-public inline fun <C, A: Ring<C>> LabeledPolynomialSpace<C, A>.LabeledPolynomial(capacity: Int, block: LabeledPolynomialBuilder<C>.() -> Unit) : LabeledPolynomial<C> = LabeledPolynomialBuilder(constantZero, { left: C, right: C -> left + right}, capacity).apply(block).build()
-
-// Waiting for context receivers :( FIXME: Replace with context receivers when they will be available
-
-@Suppress("FunctionName")
-public fun <C, A: Ring<C>> LabeledRationalFunctionSpace<C, A>.LabeledRationalFunction(numeratorCoefficients: Map<Map<Symbol, UInt>, C>, denominatorCoefficients: Map<Map<Symbol, UInt>, C>): LabeledRationalFunction<C> =
- LabeledRationalFunction<C>(
- LabeledPolynomial(numeratorCoefficients, toCheckInput = true),
- LabeledPolynomial(denominatorCoefficients, toCheckInput = true)
- )
-@Suppress("FunctionName")
-public fun <C, A: Ring<C>> A.LabeledRationalFunction(numeratorCoefficients: Map<Map<Symbol, UInt>, C>, denominatorCoefficients: Map<Map<Symbol, UInt>, C>): LabeledRationalFunction<C> =
- LabeledRationalFunction<C>(
- LabeledPolynomial(numeratorCoefficients, toCheckInput = true),
- LabeledPolynomial(denominatorCoefficients, toCheckInput = true)
- )
-@Suppress("FunctionName")
-public fun <C, A: Ring<C>> LabeledRationalFunctionSpace<C, A>.LabeledRationalFunction(numerator: LabeledPolynomial<C>): LabeledRationalFunction<C> =
- LabeledRationalFunction<C>(numerator, polynomialOne)
-@Suppress("FunctionName")
-public fun <C, A: Ring<C>> A.LabeledRationalFunction(numerator: LabeledPolynomial<C>): LabeledRationalFunction<C> =
- LabeledRationalFunction<C>(numerator, LabeledPolynomial(mapOf(emptyMap<Symbol, UInt>() to one), toCheckInput = false))
-@Suppress("FunctionName")
-public fun <C, A: Ring<C>> LabeledRationalFunctionSpace<C, A>.LabeledRationalFunction(numeratorCoefficients: Map<Map<Symbol, UInt>, C>): LabeledRationalFunction<C> =
- LabeledRationalFunction<C>(
- LabeledPolynomial(numeratorCoefficients, toCheckInput = true),
- polynomialOne
- )
-@Suppress("FunctionName")
-public fun <C, A: Ring<C>> A.LabeledRationalFunction(numeratorCoefficients: Map<Map<Symbol, UInt>, C>): LabeledRationalFunction<C> =
- LabeledRationalFunction<C>(
- LabeledPolynomial(numeratorCoefficients, toCheckInput = true),
- LabeledPolynomial(mapOf(emptyMap<Symbol, UInt>() to one), toCheckInput = false)
- )
-
-//context(A)
-//public fun <C, A: Ring<C>> Symbol.asLabeledRationalFunction() : LabeledRationalFunction<C> = LabeledRationalFunction(asLabeledPolynomial())
-//context(LabeledRationalFunctionSpace<C, A>)
-//public fun <C, A: Ring<C>> Symbol.asLabeledRationalFunction() : LabeledRationalFunction<C> = LabeledRationalFunction(asLabeledPolynomial())
-
-//context(A)
-//public fun <C, A: Ring<C>> C.asLabeledRationalFunction() : LabeledRationalFunction<C> = LabeledRationalFunction(asLabeledPolynomial())
-//context(LabeledRationalFunctionSpace<C, A>)
-//public fun <C, A: Ring<C>> C.asLabeledRationalFunction() : LabeledRationalFunction<C> = LabeledRationalFunction(asLabeledPolynomial())
\ No newline at end of file
diff --git a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/labeledPolynomialUtil.kt b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/labeledPolynomialUtil.kt
deleted file mode 100644
index af918b9ae..000000000
--- a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/labeledPolynomialUtil.kt
+++ /dev/null
@@ -1,495 +0,0 @@
-/*
- * Copyright 2018-2021 KMath contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package space.kscience.kmath.functions
-
-import space.kscience.kmath.expressions.Symbol
-import space.kscience.kmath.misc.UnstableKMathAPI
-import space.kscience.kmath.operations.Field
-import space.kscience.kmath.operations.Ring
-import space.kscience.kmath.operations.invoke
-import kotlin.contracts.ExperimentalContracts
-import kotlin.contracts.InvocationKind
-import kotlin.contracts.contract
-
-
-// TODO: Docs
-
-/**
- * Creates a [LabeledPolynomialSpace] over a received ring.
- */
-public fun <C, A : Ring<C>> A.labeledPolynomial(): LabeledPolynomialSpace<C, A> =
- LabeledPolynomialSpace(this)
-
-/**
- * Creates a [LabeledPolynomialSpace]'s scope over a received ring.
- */
-@OptIn(ExperimentalContracts::class)
-public inline fun <C, A : Ring<C>, R> A.labeledPolynomial(block: LabeledPolynomialSpace<C, A>.() -> R): R {
- contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) }
- return LabeledPolynomialSpace(this).block()
-}
-
-///**
-// * Represents the polynomial as a [String] with names of variables substituted with names from [names].
-// * Consider that monomials are sorted in lexicographic order.
-// */
-//context(LabeledPolynomialSpace<C, A>)
-//fun <C, A: Ring<C>> LabeledPolynomial<C>.represent(names: Map<Symbol, String> = emptyMap()): String =
-// coefficients.entries
-// .sortedWith { o1, o2 -> LabeledPolynomial.monomialComparator.compare(o1.key, o2.key) }
-// .asSequence()
-// .map { (degs, t) ->
-// if (degs.isEmpty()) "$t"
-// else {
-// when {
-// t.isOne() -> ""
-// t.isMinusOne() -> "-"
-// else -> "$t "
-// } +
-// degs
-// .toSortedMap()
-// .filter { it.value > 0U }
-// .map { (variable, deg) ->
-// val variableName = names.getOrDefault(variable, variable.toString())
-// when (deg) {
-// 1U -> variableName
-// else -> "$variableName^$deg"
-// }
-// }
-// .joinToString(separator = " ") { it }
-// }
-// }
-// .joinToString(separator = " + ") { it }
-// .ifEmpty { "0" }
-//
-///**
-// * Represents the polynomial as a [String] naming variables by [namer].
-// * Consider that monomials are sorted in lexicographic order.
-// */
-//context(LabeledPolynomialSpace<C, A>)
-//fun <C, A: Ring<C>> LabeledPolynomial<C>.represent(namer: (Symbol) -> String): String =
-// coefficients.entries
-// .sortedWith { o1, o2 -> LabeledPolynomial.monomialComparator.compare(o1.key, o2.key) }
-// .asSequence()
-// .map { (degs, t) ->
-// if (degs.isEmpty()) "$t"
-// else {
-// when {
-// t.isOne() -> ""
-// t.isMinusOne() -> "-"
-// else -> "$t "
-// } +
-// degs
-// .toSortedMap()
-// .filter { it.value > 0U }
-// .map { (variable, deg) ->
-// when (deg) {
-// 1U -> namer(variable)
-// else -> "${namer(variable)}^$deg"
-// }
-// }
-// .joinToString(separator = " ") { it }
-// }
-// }
-// .joinToString(separator = " + ") { it }
-// .ifEmpty { "0" }
-//
-///**
-// * Represents the polynomial as a [String] with names of variables substituted with names from [names] and with
-// * brackets around the string if needed (i.e. when there are at least two addends in the representation).
-// * Consider that monomials are sorted in lexicographic order.
-// */
-//context(LabeledPolynomialSpace<C, A>)
-//fun <C, A: Ring<C>> LabeledPolynomial<C>.representWithBrackets(names: Map<Symbol, String> = emptyMap()): String =
-// with(represent(names)) { if (coefficients.count() == 1) this else "($this)" }
-//
-///**
-// * Represents the polynomial as a [String] naming variables by [namer] and with brackets around the string if needed
-// * (i.e. when there are at least two addends in the representation).
-// * Consider that monomials are sorted in lexicographic order.
-// */
-//context(LabeledPolynomialSpace<C, A>)
-//fun <C, A: Ring<C>> LabeledPolynomial<C>.representWithBrackets(namer: (Symbol) -> String): String =
-// with(represent(namer)) { if (coefficients.count() == 1) this else "($this)" }
-//
-///**
-// * Represents the polynomial as a [String] with names of variables substituted with names from [names].
-// * Consider that monomials are sorted in **reversed** lexicographic order.
-// */
-//context(LabeledPolynomialSpace<C, A>)
-//fun <C, A: Ring<C>> LabeledPolynomial<C>.representReversed(names: Map<Symbol, String> = emptyMap()): String =
-// coefficients.entries
-// .sortedWith { o1, o2 -> -LabeledPolynomial.monomialComparator.compare(o1.key, o2.key) }
-// .asSequence()
-// .map { (degs, t) ->
-// if (degs.isEmpty()) "$t"
-// else {
-// when {
-// t.isOne() -> ""
-// t.isMinusOne() -> "-"
-// else -> "$t "
-// } +
-// degs
-// .toSortedMap()
-// .filter { it.value > 0U }
-// .map { (variable, deg) ->
-// val variableName = names.getOrDefault(variable, variable.toString())
-// when (deg) {
-// 1U -> variableName
-// else -> "$variableName^$deg"
-// }
-// }
-// .joinToString(separator = " ") { it }
-// }
-// }
-// .joinToString(separator = " + ") { it }
-// .ifEmpty { "0" }
-//
-///**
-// * Represents the polynomial as a [String] naming variables by [namer].
-// * Consider that monomials are sorted in **reversed** lexicographic order.
-// */
-//context(LabeledPolynomialSpace<C, A>)
-//fun <C, A: Ring<C>> LabeledPolynomial<C>.representReversed(namer: (Symbol) -> String): String =
-// coefficients.entries
-// .sortedWith { o1, o2 -> -LabeledPolynomial.monomialComparator.compare(o1.key, o2.key) }
-// .asSequence()
-// .map { (degs, t) ->
-// if (degs.isEmpty()) "$t"
-// else {
-// when {
-// t.isOne() -> ""
-// t.isMinusOne() -> "-"
-// else -> "$t "
-// } +
-// degs
-// .toSortedMap()
-// .filter { it.value > 0U }
-// .map { (variable, deg) ->
-// when (deg) {
-// 1U -> namer(variable)
-// else -> "${namer(variable)}^$deg"
-// }
-// }
-// .joinToString(separator = " ") { it }
-// }
-// }
-// .joinToString(separator = " + ") { it }
-// .ifEmpty { "0" }
-//
-///**
-// * Represents the polynomial as a [String] with names of variables substituted with names from [names] and with
-// * brackets around the string if needed (i.e. when there are at least two addends in the representation).
-// * Consider that monomials are sorted in **reversed** lexicographic order.
-// */
-//context(LabeledPolynomialSpace<C, A>)
-//fun <C, A: Ring<C>> LabeledPolynomial<C>.representReversedWithBrackets(names: Map<Symbol, String> = emptyMap()): String =
-// with(representReversed(names)) { if (coefficients.count() == 1) this else "($this)" }
-//
-///**
-// * Represents the polynomial as a [String] naming variables by [namer] and with brackets around the string if needed
-// * (i.e. when there are at least two addends in the representation).
-// * Consider that monomials are sorted in **reversed** lexicographic order.
-// */
-//context(LabeledPolynomialSpace<C, A>)
-//fun <C, A: Ring<C>> LabeledPolynomial<C>.representReversedWithBrackets(namer: (Symbol) -> String): String =
-// with(representReversed(namer)) { if (coefficients.count() == 1) this else "($this)" }
-
-//operator fun <T: Field<T>> Polynomial<T>.div(other: T): Polynomial<T> =
-// if (other.isZero()) throw ArithmeticException("/ by zero")
-// else
-// Polynomial(
-// coefficients
-// .mapValues { it.value / other },
-// toCheckInput = false
-// )
-
-//public fun <C> LabeledPolynomial<C>.substitute(ring: Ring<C>, args: Map<Symbol, C>): LabeledPolynomial<C> = ring {
-// if (coefficients.isEmpty()) return this@substitute
-// LabeledPolynomial<C>(
-// buildMap {
-// coefficients.forEach { (degs, c) ->
-// val newDegs = degs.filterKeys { it !in args }
-// val newC = degs.entries.asSequence().filter { it.key in args }.fold(c) { acc, (variable, deg) ->
-// multiplyWithPower(acc, args[variable]!!, deg)
-// }
-// this[newDegs] = if (newDegs in this) this[newDegs]!! + newC else newC
-// }
-// }
-// )
-//}
-//
-//// TODO: Replace with optimisation: the [result] may be unboxed, and all operations may be performed as soon as
-//// possible on it
-//@JvmName("substitutePolynomial")
-//fun <C> LabeledPolynomial<C>.substitute(ring: Ring<C>, arg: Map<Symbol, LabeledPolynomial<C>>) : LabeledPolynomial<C> =
-// ring.labeledPolynomial {
-// if (coefficients.isEmpty()) return zero
-// coefficients
-// .asSequence()
-// .map { (degs, c) ->
-// degs.entries
-// .asSequence()
-// .filter { it.key in arg }
-// .fold(LabeledPolynomial(mapOf(degs.filterKeys { it !in arg } to c))) { acc, (index, deg) ->
-// multiplyWithPower(acc, arg[index]!!, deg)
-// }
-// }
-// .reduce { acc, polynomial -> acc + polynomial } // TODO: Rewrite. Might be slow.
-// }
-//
-//// TODO: Substitute rational function
-//
-//fun <C, A : Ring<C>> LabeledPolynomial<C>.asFunctionOver(ring: A): (Map<Symbol, C>) -> LabeledPolynomial<C> =
-// { substitute(ring, it) }
-//
-//fun <C, A : Ring<C>> LabeledPolynomial<C>.asPolynomialFunctionOver(ring: A): (Map<Symbol, LabeledPolynomial<C>>) -> LabeledPolynomial<C> =
-// { substitute(ring, it) }
-
-/**
- * Returns algebraic derivative of received polynomial.
- */
-@UnstableKMathAPI
-public fun <C, A : Ring<C>> LabeledPolynomial<C>.derivativeWithRespectTo(
- algebra: A,
- variable: Symbol,
-): LabeledPolynomial<C> = algebra {
- LabeledPolynomial<C>(
- buildMap(coefficients.size) {
- coefficients
- .forEach { (degs, c) ->
- if (variable !in degs) return@forEach
- put(
- buildMap {
- degs.forEach { (vari, deg) ->
- when {
- vari != variable -> put(vari, deg)
- deg > 1u -> put(vari, deg - 1u)
- }
- }
- },
- multiplyByDoubling(c, degs[variable]!!)
- )
- }
- }
- )
-}
-
-/**
- * Returns algebraic derivative of received polynomial.
- */
-@UnstableKMathAPI
-public fun <C, A : Ring<C>> LabeledPolynomial<C>.derivativeWithRespectTo(
- algebra: A,
- variables: Collection<Symbol>,
-): LabeledPolynomial<C> = algebra {
- val cleanedVariables = variables.toSet()
- if (cleanedVariables.isEmpty()) return this@derivativeWithRespectTo
- LabeledPolynomial<C>(
- buildMap(coefficients.size) {
- coefficients
- .forEach { (degs, c) ->
- if (!degs.keys.containsAll(cleanedVariables)) return@forEach
- put(
- buildMap {
- degs.forEach { (vari, deg) ->
- when {
- vari !in cleanedVariables -> put(vari, deg)
- deg > 1u -> put(vari, deg - 1u)
- }
- }
- },
- cleanedVariables.fold(c) { acc, variable -> multiplyByDoubling(acc, degs[variable]!!) }
- )
- }
- }
- )
-}
-
-/**
- * Returns algebraic derivative of received polynomial.
- */
-@UnstableKMathAPI
-public fun <C, A : Ring<C>> LabeledPolynomial<C>.nthDerivativeWithRespectTo(
- algebra: A,
- variable: Symbol,
- order: UInt
-): LabeledPolynomial<C> = algebra {
- if (order == 0u) return this@nthDerivativeWithRespectTo
- LabeledPolynomial<C>(
- buildMap(coefficients.size) {
- coefficients
- .forEach { (degs, c) ->
- if (degs.getOrElse(variable) { 0u } < order) return@forEach
- put(
- buildMap {
- degs.forEach { (vari, deg) ->
- when {
- vari != variable -> put(vari, deg)
- deg > order -> put(vari, deg - order)
- }
- }
- },
- degs[variable]!!.let { deg ->
- (deg downTo deg - order + 1u)
- .fold(c) { acc, ord -> multiplyByDoubling(acc, ord) }
- }
- )
- }
- }
- )
-}
-
-/**
- * Returns algebraic derivative of received polynomial.
- */
-@UnstableKMathAPI
-public fun <C, A : Ring<C>> LabeledPolynomial<C>.nthDerivativeWithRespectTo(
- algebra: A,
- variablesAndOrders: Map<Symbol, UInt>,
-): LabeledPolynomial<C> = algebra {
- val filteredVariablesAndOrders = variablesAndOrders.filterValues { it != 0u }
- if (filteredVariablesAndOrders.isEmpty()) return this@nthDerivativeWithRespectTo
- LabeledPolynomial<C>(
- buildMap(coefficients.size) {
- coefficients
- .forEach { (degs, c) ->
- if (filteredVariablesAndOrders.any { (variable, order) -> degs.getOrElse(variable) { 0u } < order }) return@forEach
- put(
- buildMap {
- degs.forEach { (vari, deg) ->
- if (vari !in filteredVariablesAndOrders) put(vari, deg)
- else {
- val order = filteredVariablesAndOrders[vari]!!
- if (deg > order) put(vari, deg - order)
- }
- }
- },
- filteredVariablesAndOrders.entries.fold(c) { acc1, (index, order) ->
- degs[index]!!.let { deg ->
- (deg downTo deg - order + 1u)
- .fold(acc1) { acc2, ord -> multiplyByDoubling(acc2, ord) }
- }
- }
- )
- }
- }
- )
-}
-
-/**
- * Returns algebraic antiderivative of received polynomial.
- */
-@UnstableKMathAPI
-public fun <C, A : Field<C>> LabeledPolynomial<C>.antiderivativeWithRespectTo(
- algebra: A,
- variable: Symbol,
-): LabeledPolynomial<C> = algebra {
- LabeledPolynomial<C>(
- buildMap(coefficients.size) {
- coefficients
- .forEach { (degs, c) ->
- val newDegs = buildMap<Symbol, UInt>(degs.size + 1) {
- put(variable, 1u)
- for ((vari, deg) in degs) put(vari, deg + getOrElse(vari) { 0u })
- }
- put(
- newDegs,
- c / multiplyByDoubling(one, newDegs[variable]!!)
- )
- }
- }
- )
-}
-
-/**
- * Returns algebraic antiderivative of received polynomial.
- */
-@UnstableKMathAPI
-public fun <C, A : Field<C>> LabeledPolynomial<C>.antiderivativeWithRespectTo(
- algebra: A,
- variables: Collection<Symbol>,
-): LabeledPolynomial<C> = algebra {
- val cleanedVariables = variables.toSet()
- if (cleanedVariables.isEmpty()) return this@antiderivativeWithRespectTo
- LabeledPolynomial<C>(
- buildMap(coefficients.size) {
- coefficients
- .forEach { (degs, c) ->
- val newDegs = buildMap<Symbol, UInt>(degs.size + 1) {
- for (variable in cleanedVariables) put(variable, 1u)
- for ((vari, deg) in degs) put(vari, deg + getOrElse(vari) { 0u })
- }
- put(
- newDegs,
- cleanedVariables.fold(c) { acc, variable -> acc / multiplyByDoubling(one, newDegs[variable]!!) }
- )
- }
- }
- )
-}
-
-/**
- * Returns algebraic derivative of received polynomial.
- */
-@UnstableKMathAPI
-public fun <C, A : Field<C>> LabeledPolynomial<C>.nthAntiderivativeWithRespectTo(
- algebra: A,
- variable: Symbol,
- order: UInt
-): LabeledPolynomial<C> = algebra {
- if (order == 0u) return this@nthAntiderivativeWithRespectTo
- LabeledPolynomial<C>(
- buildMap(coefficients.size) {
- coefficients
- .forEach { (degs, c) ->
- val newDegs = buildMap<Symbol, UInt>(degs.size + 1) {
- put(variable, order)
- for ((vari, deg) in degs) put(vari, deg + getOrElse(vari) { 0u })
- }
- put(
- newDegs,
- newDegs[variable]!!.let { deg ->
- (deg downTo deg - order + 1u)
- .fold(c) { acc, ord -> acc / multiplyByDoubling(one, ord) }
- }
- )
- }
- }
- )
-}
-
-/**
- * Returns algebraic derivative of received polynomial.
- */
-@UnstableKMathAPI
-public fun <C, A : Field<C>> LabeledPolynomial<C>.nthAntiderivativeWithRespectTo(
- algebra: A,
- variablesAndOrders: Map<Symbol, UInt>,
-): LabeledPolynomial<C> = algebra {
- val filteredVariablesAndOrders = variablesAndOrders.filterValues { it != 0u }
- if (filteredVariablesAndOrders.isEmpty()) return this@nthAntiderivativeWithRespectTo
- LabeledPolynomial<C>(
- buildMap(coefficients.size) {
- coefficients
- .forEach { (degs, c) ->
- val newDegs = buildMap<Symbol, UInt>(degs.size + 1) {
- for ((variable, order) in filteredVariablesAndOrders) put(variable, order)
- for ((vari, deg) in degs) put(vari, deg + getOrElse(vari) { 0u })
- }
- put(
- newDegs,
- filteredVariablesAndOrders.entries.fold(c) { acc1, (index, order) ->
- newDegs[index]!!.let { deg ->
- (deg downTo deg - order + 1u)
- .fold(acc1) { acc2, ord -> acc2 / multiplyByDoubling(one, ord) }
- }
- }
- )
- }
- }
- )
-}
\ No newline at end of file
diff --git a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/labeledRationalFunctionUtil.kt b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/labeledRationalFunctionUtil.kt
deleted file mode 100644
index 583160cf4..000000000
--- a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/labeledRationalFunctionUtil.kt
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- * Copyright 2018-2021 KMath contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package space.kscience.kmath.functions
-
-import space.kscience.kmath.operations.Ring
-import kotlin.contracts.InvocationKind
-import kotlin.contracts.contract
-
-
-/**
- * Creates a [LabeledRationalFunctionSpace] over a received ring.
- */
-public fun <C, A : Ring<C>> A.labeledRationalFunction(): LabeledRationalFunctionSpace<C, A> =
- LabeledRationalFunctionSpace(this)
-
-/**
- * Creates a [LabeledRationalFunctionSpace]'s scope over a received ring.
- */
-public inline fun <C, A : Ring<C>, R> A.labeledRationalFunction(block: LabeledRationalFunctionSpace<C, A>.() -> R): R {
- contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) }
- return LabeledRationalFunctionSpace(this).block()
-}
-
-//fun <T: Field<T>> LabeledRationalFunction<T>.reduced(): LabeledRationalFunction<T> {
-// val greatestCommonDivider = polynomialGCD(numerator, denominator)
-// return LabeledRationalFunction(
-// numerator / greatestCommonDivider,
-// denominator / greatestCommonDivider
-// )
-//}
\ No newline at end of file
diff --git a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/listConstructors.kt b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/listConstructors.kt
index 9498c77ca..35c736914 100644
--- a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/listConstructors.kt
+++ b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/listConstructors.kt
@@ -3,58 +3,95 @@
* Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
*/
+/*
+ * Copyright 2018-2021 KMath contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
package space.kscience.kmath.functions
import space.kscience.kmath.operations.Ring
/**
- * Returns a [ListPolynomial] instance with given [coefficients]. The collection of coefficients will be reversed if
- * [reverse] parameter is true.
+ * Constructs a [ListPolynomial] instance with provided [coefficients]. The collection of coefficients will be reversed
+ * if [reverse] parameter is true.
*/
@Suppress("FunctionName")
public fun <C> ListPolynomial(coefficients: List<C>, reverse: Boolean = false): ListPolynomial<C> =
ListPolynomial(with(coefficients) { if (reverse) reversed() else this })
/**
- * Returns a [ListPolynomial] instance with given [coefficients]. The collection of coefficients will be reversed if
- * [reverse] parameter is true.
+ * Constructs a [ListPolynomial] instance with provided [coefficients]. The collection of coefficients will be reversed
+ * if [reverse] parameter is true.
*/
@Suppress("FunctionName")
public fun <C> ListPolynomial(vararg coefficients: C, reverse: Boolean = false): ListPolynomial<C> =
ListPolynomial(with(coefficients) { if (reverse) reversed() else toList() })
+/**
+ * Represents [this] constant as a [ListPolynomial].
+ */
public fun <C> C.asListPolynomial() : ListPolynomial<C> = ListPolynomial(listOf(this))
// Waiting for context receivers :( FIXME: Replace with context receivers when they will be available
+/**
+ * Constructs [ListRationalFunction] instance with numerator and denominator constructed with provided
+ * [numeratorCoefficients] and [denominatorCoefficients]. The both collections of coefficients will be reversed if
+ * [reverse] parameter is true.
+ */
@Suppress("FunctionName")
public fun <C> ListRationalFunction(numeratorCoefficients: List<C>, denominatorCoefficients: List<C>, reverse: Boolean = false): ListRationalFunction<C> =
ListRationalFunction<C>(
ListPolynomial( with(numeratorCoefficients) { if (reverse) reversed() else this } ),
ListPolynomial( with(denominatorCoefficients) { if (reverse) reversed() else this } )
)
-@Suppress("FunctionName")
-public fun <C, A: Ring<C>> ListRationalFunctionSpace<C, A>.ListRationalFunction(numerator: ListPolynomial<C>): ListRationalFunction<C> =
- ListRationalFunction<C>(numerator, polynomialOne)
+/**
+ * Constructs [ListRationalFunction] instance with provided [numerator] and unit denominator.
+ */
@Suppress("FunctionName")
public fun <C, A: Ring<C>> A.ListRationalFunction(numerator: ListPolynomial<C>): ListRationalFunction<C> =
ListRationalFunction<C>(numerator, ListPolynomial(listOf(one)))
+/**
+ * Constructs [ListRationalFunction] instance with provided [numerator] and unit denominator.
+ */
@Suppress("FunctionName")
-public fun <C, A: Ring<C>> ListRationalFunctionSpace<C, A>.ListRationalFunction(numeratorCoefficients: List<C>, reverse: Boolean = false): ListRationalFunction<C> =
- ListRationalFunction<C>(
- ListPolynomial( with(numeratorCoefficients) { if (reverse) reversed() else this } ),
- polynomialOne
- )
+public fun <C, A: Ring<C>> ListRationalFunctionSpace<C, A>.ListRationalFunction(numerator: ListPolynomial<C>): ListRationalFunction<C> =
+ ListRationalFunction<C>(numerator, polynomialOne)
+/**
+ * Constructs [ListRationalFunction] instance with numerator constructed with provided [numeratorCoefficients] and unit
+ * denominator. The collection of numerator coefficients will be reversed if [reverse] parameter is true.
+ */
@Suppress("FunctionName")
public fun <C, A: Ring<C>> A.ListRationalFunction(numeratorCoefficients: List<C>, reverse: Boolean = false): ListRationalFunction<C> =
ListRationalFunction<C>(
ListPolynomial( with(numeratorCoefficients) { if (reverse) reversed() else this } ),
ListPolynomial(listOf(one))
)
+/**
+ * Constructs [ListRationalFunction] instance with numerator constructed with provided [numeratorCoefficients] and unit
+ * denominator. The collection of numerator coefficients will be reversed if [reverse] parameter is true.
+ */
+@Suppress("FunctionName")
+public fun <C, A: Ring<C>> ListRationalFunctionSpace<C, A>.ListRationalFunction(numeratorCoefficients: List<C>, reverse: Boolean = false): ListRationalFunction<C> =
+ ListRationalFunction<C>(
+ ListPolynomial( with(numeratorCoefficients) { if (reverse) reversed() else this } ),
+ polynomialOne
+ )
+/**
+ * Represents [this] constant as a rational function.
+ */ // FIXME: When context receivers will be ready, delete this function and uncomment the following two
+public fun <C, A: Ring<C>> C.asListRationalFunction(ring: A) : ListRationalFunction<C> = ring.ListRationalFunction(asListPolynomial())
+///**
+// * Represents [this] constant as a rational function.
+// */
//context(A)
//public fun <C, A: Ring<C>> C.asListRationalFunction() : ListRationalFunction<C> = ListRationalFunction(asListPolynomial())
+///**
+// * Represents [this] constant as a rational function.
+// */
//context(ListRationalFunctionSpace<C, A>)
//public fun <C, A: Ring<C>> C.asListRationalFunction() : ListRationalFunction<C> = ListRationalFunction(asListPolynomial())
\ No newline at end of file
diff --git a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/listPolynomialUtil.kt b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/listPolynomialUtil.kt
deleted file mode 100644
index 50313cab9..000000000
--- a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/listPolynomialUtil.kt
+++ /dev/null
@@ -1,233 +0,0 @@
-/*
- * Copyright 2018-2021 KMath contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package space.kscience.kmath.functions
-
-import space.kscience.kmath.misc.UnstableKMathAPI
-import space.kscience.kmath.operations.*
-import kotlin.contracts.InvocationKind
-import kotlin.contracts.contract
-import kotlin.math.max
-import kotlin.math.min
-import kotlin.math.pow
-
-
-/**
- * Removes zeros on the end of the coefficient list of polynomial.
- */
-//context(PolynomialSpace<C, A>)
-//fun <C, A: Ring<C>> Polynomial<C>.removeZeros() : Polynomial<C> =
-// if (degree > -1) Polynomial(coefficients.subList(0, degree + 1)) else zero
-
-/**
- * Creates a [ListPolynomialSpace] over a received ring.
- */
-public fun <C, A : Ring<C>> A.listPolynomial(): ListPolynomialSpace<C, A> =
- ListPolynomialSpace(this)
-
-/**
- * Creates a [ListPolynomialSpace]'s scope over a received ring.
- */
-public inline fun <C, A : Ring<C>, R> A.listPolynomial(block: ListPolynomialSpace<C, A>.() -> R): R {
- contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) }
- return ListPolynomialSpace(this).block()
-}
-
-/**
- * Creates a [ScalableListPolynomialSpace] over a received scalable ring.
- */
-public fun <C, A> A.scalableListPolynomial(): ScalableListPolynomialSpace<C, A> where A : Ring<C>, A : ScaleOperations<C> =
- ScalableListPolynomialSpace(this)
-
-/**
- * Creates a [ScalableListPolynomialSpace]'s scope over a received scalable ring.
- */
-public inline fun <C, A, R> A.scalableListPolynomial(block: ScalableListPolynomialSpace<C, A>.() -> R): R where A : Ring<C>, A : ScaleOperations<C> {
- contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) }
- return ScalableListPolynomialSpace(this).block()
-}
-
-@Suppress("NOTHING_TO_INLINE")
-internal inline fun <C> copyTo(
- origin: List<C>,
- originDegree: Int,
- target: MutableList<C>,
-) {
- for (deg in 0 .. originDegree) target[deg] = origin[deg]
-}
-
-@Suppress("NOTHING_TO_INLINE")
-internal inline fun <C> multiplyAddingToUpdater(
- ring: Ring<C>,
- multiplicand: MutableList<C>,
- multiplicandDegree: Int,
- multiplier: List<C>,
- multiplierDegree: Int,
- updater: MutableList<C>,
- zero: C,
-) {
- multiplyAddingTo(
- ring = ring,
- multiplicand = multiplicand,
- multiplicandDegree = multiplicandDegree,
- multiplier = multiplier,
- multiplierDegree = multiplierDegree,
- target = updater
- )
- for (updateDeg in 0 .. multiplicandDegree + multiplierDegree) {
- multiplicand[updateDeg] = updater[updateDeg]
- updater[updateDeg] = zero
- }
-}
-
-@Suppress("NOTHING_TO_INLINE")
-internal inline fun <C> multiplyAddingTo(
- ring: Ring<C>,
- multiplicand: List<C>,
- multiplicandDegree: Int,
- multiplier: List<C>,
- multiplierDegree: Int,
- target: MutableList<C>
-) = ring {
- for (d in 0 .. multiplicandDegree + multiplierDegree)
- for (k in max(0, d - multiplierDegree)..min(multiplicandDegree, d))
- target[d] += multiplicand[k] * multiplier[d - k]
-}
-
-/**
- * Evaluates the value of the given double polynomial for given double argument.
- */
-public fun ListPolynomial<Double>.substitute(arg: Double): Double =
- coefficients.reduceIndexedOrNull { index, acc, c ->
- acc + c * arg.pow(index)
- } ?: .0
-
-/**
- * Evaluates the value of the given polynomial for given argument.
- *
- * It is an implementation of [Horner's method](https://en.wikipedia.org/wiki/Horner%27s_method).
- */
-public fun <C> ListPolynomial<C>.substitute(ring: Ring<C>, arg: C): C = ring {
- if (coefficients.isEmpty()) return@ring zero
- var result: C = coefficients.last()
- for (j in coefficients.size - 2 downTo 0) {
- result = (arg * result) + coefficients[j]
- }
- return result
-}
-
-public fun <C> ListPolynomial<C>.substitute(ring: Ring<C>, arg: ListPolynomial<C>) : ListPolynomial<C> = ring {
- if (coefficients.isEmpty()) return ListPolynomial(emptyList())
-
- val thisDegree = coefficients.lastIndex
- if (thisDegree == -1) return ListPolynomial(emptyList())
- val argDegree = arg.coefficients.lastIndex
- if (argDegree == -1) return coefficients[0].asListPolynomial()
- val constantZero = zero
- val resultCoefs: MutableList<C> = MutableList(thisDegree * argDegree + 1) { constantZero }
- resultCoefs[0] = coefficients[thisDegree]
- val resultCoefsUpdate: MutableList<C> = MutableList(thisDegree * argDegree + 1) { constantZero }
- var resultDegree = 0
- for (deg in thisDegree - 1 downTo 0) {
- resultCoefsUpdate[0] = coefficients[deg]
- multiplyAddingToUpdater(
- ring = ring,
- multiplicand = resultCoefs,
- multiplicandDegree = resultDegree,
- multiplier = arg.coefficients,
- multiplierDegree = argDegree,
- updater = resultCoefsUpdate,
- zero = constantZero
- )
- resultDegree += argDegree
- }
-
- return ListPolynomial<C>(resultCoefs)
-}
-
-/**
- * Represent the polynomial as a regular context-less function.
- */
-public fun <C, A : Ring<C>> ListPolynomial<C>.asFunction(ring: A): (C) -> C = { substitute(ring, it) }
-
-/**
- * Represent the polynomial as a regular context-less function.
- */
-public fun <C, A : Ring<C>> ListPolynomial<C>.asPolynomialFunctionOver(ring: A): (ListPolynomial<C>) -> ListPolynomial<C> = { substitute(ring, it) }
-
-/**
- * Returns algebraic derivative of received polynomial.
- */
-@UnstableKMathAPI
-public fun <C, A> ListPolynomial<C>.derivative(
- algebra: A,
-): ListPolynomial<C> where A : Ring<C>, A : NumericAlgebra<C> = algebra {
- ListPolynomial(
- buildList(max(0, coefficients.size - 1)) {
- for (deg in 1 .. coefficients.lastIndex) add(number(deg) * coefficients[deg])
- }
- )
-}
-
-/**
- * Returns algebraic derivative of received polynomial.
- */
-@UnstableKMathAPI
-public fun <C, A> ListPolynomial<C>.nthDerivative(
- algebra: A,
- order: Int,
-): ListPolynomial<C> where A : Ring<C>, A : NumericAlgebra<C> = algebra {
- require(order >= 0) { "Order of derivative must be non-negative" }
- ListPolynomial(
- buildList(max(0, coefficients.size - order)) {
- for (deg in order.. coefficients.lastIndex)
- add((deg - order + 1 .. deg).fold(coefficients[deg]) { acc, d -> acc * number(d) })
- }
- )
-}
-
-/**
- * Returns algebraic antiderivative of received polynomial.
- */
-@UnstableKMathAPI
-public fun <C, A> ListPolynomial<C>.antiderivative(
- algebra: A,
-): ListPolynomial<C> where A : Field<C>, A : NumericAlgebra<C> = algebra {
- ListPolynomial(
- buildList(coefficients.size + 1) {
- add(zero)
- coefficients.mapIndexedTo(this) { index, t -> t / number(index + 1) }
- }
- )
-}
-
-/**
- * Returns algebraic antiderivative of received polynomial.
- */
-@UnstableKMathAPI
-public fun <C, A> ListPolynomial<C>.nthAntiderivative(
- algebra: A,
- order: Int,
-): ListPolynomial<C> where A : Field<C>, A : NumericAlgebra<C> = algebra {
- require(order >= 0) { "Order of antiderivative must be non-negative" }
- ListPolynomial(
- buildList(coefficients.size + order) {
- repeat(order) { add(zero) }
- coefficients.mapIndexedTo(this) { index, c -> (1..order).fold(c) { acc, i -> acc / number(index + i) } }
- }
- )
-}
-
-/**
- * Compute a definite integral of a given polynomial in a [range]
- */
-@UnstableKMathAPI
-public fun <C : Comparable<C>> ListPolynomial<C>.integrate(
- algebra: Field<C>,
- range: ClosedRange<C>,
-): C = algebra {
- val integral = antiderivative(algebra)
- integral.substitute(algebra, range.endInclusive) - integral.substitute(algebra, range.start)
-}
\ No newline at end of file
diff --git a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/listUtil.kt b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/listUtil.kt
new file mode 100644
index 000000000..127dd8c7a
--- /dev/null
+++ b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/listUtil.kt
@@ -0,0 +1,268 @@
+/*
+ * Copyright 2018-2021 KMath contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package space.kscience.kmath.functions
+
+import space.kscience.kmath.misc.UnstableKMathAPI
+import space.kscience.kmath.operations.*
+import kotlin.contracts.InvocationKind
+import kotlin.contracts.contract
+import kotlin.math.max
+import kotlin.math.pow
+
+
+/**
+ * Creates a [ListPolynomialSpace] over a received ring.
+ */
+public fun <C, A : Ring<C>> A.listPolynomialSpace(): ListPolynomialSpace<C, A> =
+ ListPolynomialSpace(this)
+
+/**
+ * Creates a [ListPolynomialSpace]'s scope over a received ring.
+ */ // TODO: When context will be ready move [ListPolynomialSpace] and add [A] to context receivers of [block]
+public inline fun <C, A : Ring<C>, R> A.listPolynomialSpace(block: ListPolynomialSpace<C, A>.() -> R): R {
+ contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) }
+ return ListPolynomialSpace(this).block()
+}
+
+/**
+ * Creates a [ScalableListPolynomialSpace] over a received scalable ring.
+ */
+public fun <C, A> A.scalableListPolynomialSpace(): ScalableListPolynomialSpace<C, A> where A : Ring<C>, A : ScaleOperations<C> =
+ ScalableListPolynomialSpace(this)
+
+/**
+ * Creates a [ScalableListPolynomialSpace]'s scope over a received scalable ring.
+ */ // TODO: When context will be ready move [ListPolynomialSpace] and add [A] to context receivers of [block]
+public inline fun <C, A, R> A.scalableListPolynomialSpace(block: ScalableListPolynomialSpace<C, A>.() -> R): R where A : Ring<C>, A : ScaleOperations<C> {
+ contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) }
+ return ScalableListPolynomialSpace(this).block()
+}
+
+/**
+ * Creates a [ListRationalFunctionSpace] over a received ring.
+ */
+public fun <C, A : Ring<C>> A.listRationalFunctionSpace(): ListRationalFunctionSpace<C, A> =
+ ListRationalFunctionSpace(this)
+
+/**
+ * Creates a [ListRationalFunctionSpace]'s scope over a received ring.
+ */ // TODO: When context will be ready move [ListRationalFunctionSpace] and add [A] to context receivers of [block]
+public inline fun <C, A : Ring<C>, R> A.listRationalFunctionSpace(block: ListRationalFunctionSpace<C, A>.() -> R): R {
+ contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) }
+ return ListRationalFunctionSpace(this).block()
+}
+
+
+/**
+ * Evaluates value of [this] Double polynomial on provided Double argument.
+ */
+public fun ListPolynomial<Double>.substitute(arg: Double): Double =
+ coefficients.reduceIndexedOrNull { index, acc, c ->
+ acc + c * arg.pow(index)
+ } ?: .0
+
+/**
+ * Evaluates value of [this] polynomial on provided argument.
+ *
+ * It is an implementation of [Horner's method](https://en.wikipedia.org/wiki/Horner%27s_method).
+ */
+public fun <C> ListPolynomial<C>.substitute(ring: Ring<C>, arg: C): C = ring {
+ if (coefficients.isEmpty()) return zero
+ var result: C = coefficients.last()
+ for (j in coefficients.size - 2 downTo 0) {
+ result = (arg * result) + coefficients[j]
+ }
+ return result
+}
+
+/**
+ * Substitutes provided polynomial [arg] into [this] polynomial.
+ *
+ * It is an implementation of [Horner's method](https://en.wikipedia.org/wiki/Horner%27s_method).
+ */ // TODO: To optimize boxing
+public fun <C> ListPolynomial<C>.substitute(ring: Ring<C>, arg: ListPolynomial<C>) : ListPolynomial<C> =
+ ring.listPolynomialSpace {
+ if (coefficients.isEmpty()) return zero
+ var result: ListPolynomial<C> = coefficients.last().asPolynomial()
+ for (j in coefficients.size - 2 downTo 0) {
+ result = (arg * result) + coefficients[j]
+ }
+ return result
+ }
+
+/**
+ * Substitutes provided rational function [arg] into [this] polynomial.
+ *
+ * It is an implementation of [Horner's method](https://en.wikipedia.org/wiki/Horner%27s_method).
+ */ // TODO: To optimize boxing
+public fun <C> ListPolynomial<C>.substitute(ring: Ring<C>, arg: ListRationalFunction<C>) : ListRationalFunction<C> =
+ ring.listRationalFunctionSpace {
+ if (coefficients.isEmpty()) return zero
+ var result: ListRationalFunction<C> = coefficients.last().asRationalFunction()
+ for (j in coefficients.size - 2 downTo 0) {
+ result = (arg * result) + coefficients[j]
+ }
+ return result
+ }
+
+/**
+ * Evaluates value of [this] Double rational function in provided Double argument.
+ */
+public fun ListRationalFunction<Double>.substitute(arg: Double): Double =
+ numerator.substitute(arg) / denominator.substitute(arg)
+
+/**
+ * Evaluates value of [this] polynomial for provided argument.
+ *
+ * It is an implementation of [Horner's method](https://en.wikipedia.org/wiki/Horner%27s_method).
+ */
+public fun <C> ListRationalFunction<C>.substitute(ring: Field<C>, arg: C): C = ring {
+ numerator.substitute(ring, arg) / denominator.substitute(ring, arg)
+}
+
+/**
+ * Substitutes provided polynomial [arg] into [this] rational function.
+ */ // TODO: To optimize boxing
+public fun <C> ListRationalFunction<C>.substitute(ring: Ring<C>, arg: ListPolynomial<C>) : ListRationalFunction<C> =
+ ring.listRationalFunctionSpace {
+ numerator.substitute(ring, arg) / denominator.substitute(ring, arg)
+ }
+
+/**
+ * Substitutes provided rational function [arg] into [this] rational function.
+ */ // TODO: To optimize boxing
+public fun <C> ListRationalFunction<C>.substitute(ring: Ring<C>, arg: ListRationalFunction<C>) : ListRationalFunction<C> =
+ ring.listRationalFunctionSpace {
+ numerator.substitute(ring, arg) / denominator.substitute(ring, arg)
+ }
+
+/**
+ * Represent [this] polynomial as a regular context-less function.
+ */
+public fun <C, A : Ring<C>> ListPolynomial<C>.asFunctionOver(ring: A): (C) -> C = { substitute(ring, it) }
+
+/**
+ * Represent [this] polynomial as a regular context-less function.
+ */
+public fun <C, A : Ring<C>> ListPolynomial<C>.asPolynomialFunctionOver(ring: A): (ListPolynomial<C>) -> ListPolynomial<C> = { substitute(ring, it) }
+
+/**
+ * Represent [this] polynomial as a regular context-less function.
+ */
+public fun <C, A : Ring<C>> ListPolynomial<C>.asFunctionOfRationalFunctionOver(ring: A): (ListPolynomial<C>) -> ListPolynomial<C> = { substitute(ring, it) }
+
+/**
+ * Represent [this] rational function as a regular context-less function.
+ */
+public fun <C, A : Field<C>> ListRationalFunction<C>.asFunctionOver(ring: A): (C) -> C = { substitute(ring, it) }
+
+/**
+ * Represent [this] rational function as a regular context-less function.
+ */
+public fun <C, A : Ring<C>> ListRationalFunction<C>.asPolynomialFunctionOver(ring: A): (ListPolynomial<C>) -> ListRationalFunction<C> = { substitute(ring, it) }
+
+/**
+ * Represent [this] rational function as a regular context-less function.
+ */
+public fun <C, A : Ring<C>> ListRationalFunction<C>.asFunctionOfRationalFunctionOver(ring: A): (ListPolynomial<C>) -> ListRationalFunction<C> = { substitute(ring, it) }
+
+/**
+ * Returns algebraic derivative of received polynomial.
+ */
+@UnstableKMathAPI
+public fun <C, A> ListPolynomial<C>.derivative(
+ ring: A,
+): ListPolynomial<C> where A : Ring<C>, A : NumericAlgebra<C> = ring {
+ ListPolynomial(
+ buildList(max(0, coefficients.size - 1)) {
+ for (deg in 1 .. coefficients.lastIndex) add(number(deg) * coefficients[deg])
+ }
+ )
+}
+
+/**
+ * Returns algebraic derivative of received polynomial of specified [order]. The [order] should be non-negative integer.
+ */
+@UnstableKMathAPI
+public fun <C, A> ListPolynomial<C>.nthDerivative(
+ ring: A,
+ order: Int,
+): ListPolynomial<C> where A : Ring<C>, A : NumericAlgebra<C> = ring {
+ require(order >= 0) { "Order of derivative must be non-negative" }
+ ListPolynomial(
+ buildList(max(0, coefficients.size - order)) {
+ for (deg in order.. coefficients.lastIndex)
+ add((deg - order + 1 .. deg).fold(coefficients[deg]) { acc, d -> acc * number(d) })
+ }
+ )
+}
+
+/**
+ * Returns algebraic antiderivative of received polynomial.
+ */
+@UnstableKMathAPI
+public fun <C, A> ListPolynomial<C>.antiderivative(
+ ring: A,
+): ListPolynomial<C> where A : Field<C>, A : NumericAlgebra<C> = ring {
+ ListPolynomial(
+ buildList(coefficients.size + 1) {
+ add(zero)
+ coefficients.mapIndexedTo(this) { index, t -> t / number(index + 1) }
+ }
+ )
+}
+
+/**
+ * Returns algebraic antiderivative of received polynomial of specified [order]. The [order] should be non-negative integer.
+ */
+@UnstableKMathAPI
+public fun <C, A> ListPolynomial<C>.nthAntiderivative(
+ ring: A,
+ order: Int,
+): ListPolynomial<C> where A : Field<C>, A : NumericAlgebra<C> = ring {
+ require(order >= 0) { "Order of antiderivative must be non-negative" }
+ ListPolynomial(
+ buildList(coefficients.size + order) {
+ repeat(order) { add(zero) }
+ coefficients.mapIndexedTo(this) { index, c -> (1..order).fold(c) { acc, i -> acc / number(index + i) } }
+ }
+ )
+}
+
+/**
+ * Computes a definite integral of [this] polynomial in the specified [range].
+ */
+@UnstableKMathAPI
+public fun <C : Comparable<C>> ListPolynomial<C>.integrate(
+ ring: Field<C>,
+ range: ClosedRange<C>,
+): C = ring {
+ val antiderivative = antiderivative(ring)
+ antiderivative.substitute(ring, range.endInclusive) - antiderivative.substitute(ring, range.start)
+}
+
+/**
+ * Returns algebraic derivative of received rational function.
+ */
+@UnstableKMathAPI
+public fun <C, A> ListRationalFunction<C>.derivative(
+ ring: A,
+): ListRationalFunction<C> where A : Ring<C>, A : NumericAlgebra<C> = ring.listRationalFunctionSpace {
+ ListRationalFunction(
+ numerator.derivative(ring) * denominator - numerator * denominator.derivative(ring),
+ denominator * denominator
+ )
+}
+
+/**
+ * Returns algebraic derivative of received rational function of specified [order]. The [order] should be non-negative integer.
+ */
+@UnstableKMathAPI
+public tailrec fun <C, A> ListRationalFunction<C>.nthDerivative(
+ ring: A,
+ order: Int,
+): ListRationalFunction<C> where A : Ring<C>, A : NumericAlgebra<C> =
+ if (order == 0) this else derivative(ring).nthDerivative(ring, order - 1)
\ No newline at end of file
diff --git a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/listRationalFunctionUtil.kt b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/listUtilOptimized.kt
similarity index 72%
rename from kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/listRationalFunctionUtil.kt
rename to kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/listUtilOptimized.kt
index 367212588..6eb3a1dc7 100644
--- a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/listRationalFunctionUtil.kt
+++ b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/listUtilOptimized.kt
@@ -5,41 +5,91 @@
package space.kscience.kmath.functions
-import space.kscience.kmath.operations.Field
import space.kscience.kmath.operations.Ring
import space.kscience.kmath.operations.invoke
-import kotlin.contracts.InvocationKind
-import kotlin.contracts.contract
import kotlin.math.max
+import kotlin.math.min
-/**
- * Creates a [ListRationalFunctionSpace] over a received ring.
- */
-public fun <C, A : Ring<C>> A.listRationalFunction(): ListRationalFunctionSpace<C, A> =
- ListRationalFunctionSpace(this)
-
-/**
- * Creates a [ListRationalFunctionSpace]'s scope over a received ring.
- */
-public inline fun <C, A : Ring<C>, R> A.listRationalFunction(block: ListRationalFunctionSpace<C, A>.() -> R): R {
- contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) }
- return ListRationalFunctionSpace(this).block()
+// TODO: Optimized copies of substitution and invocation
+@UnstablePolynomialBoxingOptimization
+@Suppress("NOTHING_TO_INLINE")
+internal inline fun <C> copyTo(
+ origin: List<C>,
+ originDegree: Int,
+ target: MutableList<C>,
+) {
+ for (deg in 0 .. originDegree) target[deg] = origin[deg]
}
-/**
- * Evaluates the value of the given double polynomial for given double argument.
- */
-public fun ListRationalFunction<Double>.substitute(arg: Double): Double =
- numerator.substitute(arg) / denominator.substitute(arg)
+@UnstablePolynomialBoxingOptimization
+@Suppress("NOTHING_TO_INLINE")
+internal inline fun <C> multiplyAddingToUpdater(
+ ring: Ring<C>,
+ multiplicand: MutableList<C>,
+ multiplicandDegree: Int,
+ multiplier: List<C>,
+ multiplierDegree: Int,
+ updater: MutableList<C>,
+ zero: C,
+) {
+ multiplyAddingTo(
+ ring = ring,
+ multiplicand = multiplicand,
+ multiplicandDegree = multiplicandDegree,
+ multiplier = multiplier,
+ multiplierDegree = multiplierDegree,
+ target = updater
+ )
+ for (updateDeg in 0 .. multiplicandDegree + multiplierDegree) {
+ multiplicand[updateDeg] = updater[updateDeg]
+ updater[updateDeg] = zero
+ }
+}
-/**
- * Evaluates the value of the given polynomial for given argument.
- *
- * It is an implementation of [Horner's method](https://en.wikipedia.org/wiki/Horner%27s_method).
- */
-public fun <C> ListRationalFunction<C>.substitute(ring: Field<C>, arg: C): C = ring {
- numerator.substitute(ring, arg) / denominator.substitute(ring, arg)
+@UnstablePolynomialBoxingOptimization
+@Suppress("NOTHING_TO_INLINE")
+internal inline fun <C> multiplyAddingTo(
+ ring: Ring<C>,
+ multiplicand: List<C>,
+ multiplicandDegree: Int,
+ multiplier: List<C>,
+ multiplierDegree: Int,
+ target: MutableList<C>
+) = ring {
+ for (d in 0 .. multiplicandDegree + multiplierDegree)
+ for (k in max(0, d - multiplierDegree)..min(multiplicandDegree, d))
+ target[d] += multiplicand[k] * multiplier[d - k]
+}
+
+@UnstablePolynomialBoxingOptimization
+public fun <C> ListPolynomial<C>.substitute2(ring: Ring<C>, arg: ListPolynomial<C>) : ListPolynomial<C> = ring {
+ if (coefficients.isEmpty()) return ListPolynomial(emptyList())
+
+ val thisDegree = coefficients.lastIndex
+ if (thisDegree == -1) return ListPolynomial(emptyList())
+ val argDegree = arg.coefficients.lastIndex
+ if (argDegree == -1) return coefficients[0].asListPolynomial()
+ val constantZero = zero
+ val resultCoefs: MutableList<C> = MutableList(thisDegree * argDegree + 1) { constantZero }
+ resultCoefs[0] = coefficients[thisDegree]
+ val resultCoefsUpdate: MutableList<C> = MutableList(thisDegree * argDegree + 1) { constantZero }
+ var resultDegree = 0
+ for (deg in thisDegree - 1 downTo 0) {
+ resultCoefsUpdate[0] = coefficients[deg]
+ multiplyAddingToUpdater(
+ ring = ring,
+ multiplicand = resultCoefs,
+ multiplicandDegree = resultDegree,
+ multiplier = arg.coefficients,
+ multiplierDegree = argDegree,
+ updater = resultCoefsUpdate,
+ zero = constantZero
+ )
+ resultDegree += argDegree
+ }
+
+ return ListPolynomial<C>(resultCoefs)
}
/**
@@ -52,6 +102,7 @@ public fun <C> ListRationalFunction<C>.substitute(ring: Field<C>, arg: C): C = r
*
* Used in [ListPolynomial.substitute] and [ListRationalFunction.substitute] for performance optimisation.
*/ // TODO: Дописать
+@UnstablePolynomialBoxingOptimization
internal fun <C> ListPolynomial<C>.substituteRationalFunctionTakeNumerator(ring: Ring<C>, arg: ListRationalFunction<C>): ListPolynomial<C> = ring {
if (coefficients.isEmpty()) return ListPolynomial(emptyList())
@@ -196,26 +247,4 @@ internal fun <C> ListPolynomial<C>.substituteRationalFunctionTakeNumerator(ring:
end = thisDegree + 1
)
)
-}
-
-//operator fun <T: Field<T>> RationalFunction<T>.invoke(arg: T): T = numerator(arg) / denominator(arg)
-//
-//fun <T: Field<T>> RationalFunction<T>.reduced(): RationalFunction<T> =
-// polynomialGCD(numerator, denominator).let {
-// RationalFunction(
-// numerator / it,
-// denominator / it
-// )
-// }
-
-///**
-// * Returns result of applying formal derivative to the polynomial.
-// *
-// * @param T Field where we are working now.
-// * @return Result of the operator.
-// */
-//fun <T: Ring<T>> RationalFunction<T>.derivative() =
-// RationalFunction(
-// numerator.derivative() * denominator - denominator.derivative() * numerator,
-// denominator * denominator
-// )
\ No newline at end of file
+}
\ No newline at end of file
diff --git a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/misc.kt b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/misc.kt
new file mode 100644
index 000000000..8b6fac39e
--- /dev/null
+++ b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/misc.kt
@@ -0,0 +1,13 @@
+/*
+ * Copyright 2018-2021 KMath contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package space.kscience.kmath.functions
+
+
+@RequiresOptIn(
+ message = "It's copy of operation with optimized boxing. It's currently unstable.",
+ level = RequiresOptIn.Level.ERROR
+)
+internal annotation class UnstablePolynomialBoxingOptimization
\ No newline at end of file
diff --git a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/numberedConstructors.kt b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/numberedConstructors.kt
deleted file mode 100644
index dca8a0cff..000000000
--- a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/numberedConstructors.kt
+++ /dev/null
@@ -1,195 +0,0 @@
-/*
- * Copyright 2018-2021 KMath contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package space.kscience.kmath.functions
-
-import space.kscience.kmath.misc.UnstableKMathAPI
-import space.kscience.kmath.operations.Ring
-
-
-/**
- * Returns the same degrees' description of the monomial, but without extra zero degrees on the end.
- */
-internal fun List<UInt>.cleanUp() = subList(0, indexOfLast { it != 0U } + 1)
-
-// Waiting for context receivers :( FIXME: Replace with context receivers when they will be available
-
-@Suppress("FunctionName", "NOTHING_TO_INLINE")
-internal inline fun <C, A: Ring<C>> NumberedPolynomialSpace<C, A>.NumberedPolynomial(coefs: Map<List<UInt>, C>, toCheckInput: Boolean = true) : NumberedPolynomial<C> = ring.NumberedPolynomial(coefs, toCheckInput)
-@Suppress("FunctionName", "NOTHING_TO_INLINE")
-internal inline fun <C, A: Ring<C>> NumberedRationalFunctionSpace<C, A>.NumberedPolynomial(coefs: Map<List<UInt>, C>, toCheckInput: Boolean = true) : NumberedPolynomial<C> = ring.NumberedPolynomial(coefs, toCheckInput)
-@Suppress("FunctionName")
-internal fun <C, A: Ring<C>> A.NumberedPolynomial(coefs: Map<List<UInt>, C>, toCheckInput: Boolean = true) : NumberedPolynomial<C> {
- if (!toCheckInput) return NumberedPolynomial<C>(coefs)
-
- val fixedCoefs = mutableMapOf<List<UInt>, C>()
-
- for (entry in coefs) {
- val key = entry.key.cleanUp()
- val value = entry.value
- fixedCoefs[key] = if (key in fixedCoefs) fixedCoefs[key]!! + value else value
- }
-
- return NumberedPolynomial<C>(fixedCoefs)
-}
-
-@Suppress("FunctionName", "NOTHING_TO_INLINE")
-internal inline fun <C, A: Ring<C>> NumberedPolynomialSpace<C, A>.NumberedPolynomial(pairs: Collection<Pair<List<UInt>, C>>, toCheckInput: Boolean = true) : NumberedPolynomial<C> = ring.NumberedPolynomial(pairs, toCheckInput)
-@Suppress("FunctionName", "NOTHING_TO_INLINE")
-internal inline fun <C, A: Ring<C>> NumberedRationalFunctionSpace<C, A>.NumberedPolynomial(pairs: Collection<Pair<List<UInt>, C>>, toCheckInput: Boolean = true) : NumberedPolynomial<C> = ring.NumberedPolynomial(pairs, toCheckInput)
-@Suppress("FunctionName")
-internal fun <C, A: Ring<C>> A.NumberedPolynomial(pairs: Collection<Pair<List<UInt>, C>>, toCheckInput: Boolean = true) : NumberedPolynomial<C> {
- if (!toCheckInput) return NumberedPolynomial<C>(pairs.toMap())
-
- val fixedCoefs = mutableMapOf<List<UInt>, C>()
-
- for (entry in pairs) {
- val key = entry.first.cleanUp()
- val value = entry.second
- fixedCoefs[key] = if (key in fixedCoefs) fixedCoefs[key]!! + value else value
- }
-
- return NumberedPolynomial<C>(fixedCoefs)
-}
-
-@Suppress("FunctionName", "NOTHING_TO_INLINE")
-internal inline fun <C, A: Ring<C>> NumberedPolynomialSpace<C, A>.NumberedPolynomial(vararg pairs: Pair<List<UInt>, C>, toCheckInput: Boolean = true) : NumberedPolynomial<C> = ring.NumberedPolynomial(pairs = pairs, toCheckInput = toCheckInput)
-@Suppress("FunctionName", "NOTHING_TO_INLINE")
-internal inline fun <C, A: Ring<C>> NumberedRationalFunctionSpace<C, A>.NumberedPolynomial(vararg pairs: Pair<List<UInt>, C>, toCheckInput: Boolean = true) : NumberedPolynomial<C> = ring.NumberedPolynomial(pairs = pairs, toCheckInput = toCheckInput)
-@Suppress("FunctionName")
-internal fun <C, A: Ring<C>> A.NumberedPolynomial(vararg pairs: Pair<List<UInt>, C>, toCheckInput: Boolean = true) : NumberedPolynomial<C> {
- if (!toCheckInput) return NumberedPolynomial<C>(pairs.toMap())
-
- val fixedCoefs = mutableMapOf<List<UInt>, C>()
-
- for (entry in pairs) {
- val key = entry.first.cleanUp()
- val value = entry.second
- fixedCoefs[key] = if (key in fixedCoefs) fixedCoefs[key]!! + value else value
- }
-
- return NumberedPolynomial<C>(fixedCoefs)
-}
-
-@Suppress("FunctionName")
-public fun <C, A: Ring<C>> A.NumberedPolynomial(coefs: Map<List<UInt>, C>) : NumberedPolynomial<C> = NumberedPolynomial(coefs, toCheckInput = true)
-@Suppress("FunctionName")
-public fun <C, A: Ring<C>> NumberedPolynomialSpace<C, A>.NumberedPolynomial(coefs: Map<List<UInt>, C>) : NumberedPolynomial<C> = NumberedPolynomial(coefs, toCheckInput = true)
-@Suppress("FunctionName")
-public fun <C, A: Ring<C>> NumberedRationalFunctionSpace<C, A>.NumberedPolynomial(coefs: Map<List<UInt>, C>) : NumberedPolynomial<C> = NumberedPolynomial(coefs, toCheckInput = true)
-
-@Suppress("FunctionName")
-public fun <C, A: Ring<C>> A.NumberedPolynomial(pairs: Collection<Pair<List<UInt>, C>>) : NumberedPolynomial<C> = NumberedPolynomial(pairs, toCheckInput = true)
-@Suppress("FunctionName")
-public fun <C, A: Ring<C>> NumberedPolynomialSpace<C, A>.NumberedPolynomial(pairs: Collection<Pair<List<UInt>, C>>) : NumberedPolynomial<C> = NumberedPolynomial(pairs, toCheckInput = true)
-@Suppress("FunctionName")
-public fun <C, A: Ring<C>> NumberedRationalFunctionSpace<C, A>.NumberedPolynomial(pairs: Collection<Pair<List<UInt>, C>>) : NumberedPolynomial<C> = NumberedPolynomial(pairs, toCheckInput = true)
-
-@Suppress("FunctionName")
-public fun <C, A: Ring<C>> A.NumberedPolynomial(vararg pairs: Pair<List<UInt>, C>) : NumberedPolynomial<C> = NumberedPolynomial(*pairs, toCheckInput = true)
-@Suppress("FunctionName")
-public fun <C, A: Ring<C>> NumberedPolynomialSpace<C, A>.NumberedPolynomial(vararg pairs: Pair<List<UInt>, C>) : NumberedPolynomial<C> = NumberedPolynomial(*pairs, toCheckInput = true)
-@Suppress("FunctionName")
-public fun <C, A: Ring<C>> NumberedRationalFunctionSpace<C, A>.NumberedPolynomial(vararg pairs: Pair<List<UInt>, C>) : NumberedPolynomial<C> = NumberedPolynomial(*pairs, toCheckInput = true)
-
-public fun <C> C.asNumberedPolynomial() : NumberedPolynomial<C> = NumberedPolynomial<C>(mapOf(emptyList<UInt>() to this))
-
-@DslMarker
-@UnstableKMathAPI
-internal annotation class NumberedPolynomialConstructorDSL
-
-@UnstableKMathAPI
-@NumberedPolynomialConstructorDSL
-public class NumberedPolynomialTermSignatureBuilder {
- private val signature: MutableList<UInt> = ArrayList()
- public fun build(): List<UInt> = signature
- public infix fun Int.inPowerOf(deg: UInt) {
- if (this > signature.lastIndex) {
- signature.addAll(List(this - signature.lastIndex - 1) { 0u })
- signature.add(deg)
- } else {
- signature[this] = deg
- }
- }
- @Suppress("NOTHING_TO_INLINE")
- public inline infix fun Int.pow(deg: UInt): Unit = this inPowerOf deg
- @Suppress("NOTHING_TO_INLINE")
- public inline infix fun Int.`in`(deg: UInt): Unit = this inPowerOf deg
- @Suppress("NOTHING_TO_INLINE")
- public inline infix fun Int.of(deg: UInt): Unit = this inPowerOf deg
-}
-
-@UnstableKMathAPI
-public class NumberedPolynomialBuilder<C>(private val zero: C, private val add: (C, C) -> C, capacity: Int = 0) {
- private val coefficients: MutableMap<List<UInt>, C> = LinkedHashMap(capacity)
- public fun build(): NumberedPolynomial<C> = NumberedPolynomial<C>(coefficients)
- public operator fun C.invoke(block: NumberedPolynomialTermSignatureBuilder.() -> Unit) {
- val signature = NumberedPolynomialTermSignatureBuilder().apply(block).build()
- coefficients[signature] = add(coefficients.getOrElse(signature) { zero }, this@invoke)
- }
- @Suppress("NOTHING_TO_INLINE")
- public inline infix fun C.with(noinline block: NumberedPolynomialTermSignatureBuilder.() -> Unit): Unit = this.invoke(block)
- @Suppress("NOTHING_TO_INLINE")
- public inline infix fun (NumberedPolynomialTermSignatureBuilder.() -> Unit).with(coef: C): Unit = coef.invoke(this)
- @Suppress("NOTHING_TO_INLINE")
- public infix fun sig(block: NumberedPolynomialTermSignatureBuilder.() -> Unit): NumberedPolynomialTermSignatureBuilder.() -> Unit = block
-}
-
-// Waiting for context receivers :( FIXME: Replace with context receivers when they will be available
-
-@UnstableKMathAPI
-@NumberedPolynomialConstructorDSL
-@Suppress("FunctionName")
-public inline fun <C, A: Ring<C>> A.NumberedPolynomial(block: NumberedPolynomialBuilder<C>.() -> Unit) : NumberedPolynomial<C> = NumberedPolynomialBuilder(zero, ::add).apply(block).build()
-@UnstableKMathAPI
-@NumberedPolynomialConstructorDSL
-@Suppress("FunctionName")
-public inline fun <C, A: Ring<C>> A.NumberedPolynomial(capacity: Int, block: NumberedPolynomialBuilder<C>.() -> Unit) : NumberedPolynomial<C> = NumberedPolynomialBuilder(zero, ::add, capacity).apply(block).build()
-@UnstableKMathAPI
-@NumberedPolynomialConstructorDSL
-@Suppress("FunctionName")
-public inline fun <C, A: Ring<C>> NumberedPolynomialSpace<C, A>.NumberedPolynomial(block: NumberedPolynomialBuilder<C>.() -> Unit) : NumberedPolynomial<C> = NumberedPolynomialBuilder(constantZero, { left: C, right: C -> left + right}).apply(block).build()
-@UnstableKMathAPI
-@NumberedPolynomialConstructorDSL
-@Suppress("FunctionName")
-public inline fun <C, A: Ring<C>> NumberedPolynomialSpace<C, A>.NumberedPolynomial(capacity: Int, block: NumberedPolynomialBuilder<C>.() -> Unit) : NumberedPolynomial<C> = NumberedPolynomialBuilder(constantZero, { left: C, right: C -> left + right}, capacity).apply(block).build()
-
-// Waiting for context receivers :( FIXME: Replace with context receivers when they will be available
-
-@Suppress("FunctionName")
-public fun <C, A: Ring<C>> NumberedRationalFunctionSpace<C, A>.NumberedRationalFunction(numeratorCoefficients: Map<List<UInt>, C>, denominatorCoefficients: Map<List<UInt>, C>): NumberedRationalFunction<C> =
- NumberedRationalFunction<C>(
- NumberedPolynomial(numeratorCoefficients, toCheckInput = true),
- NumberedPolynomial(denominatorCoefficients, toCheckInput = true)
- )
-@Suppress("FunctionName")
-public fun <C, A: Ring<C>> A.NumberedRationalFunction(numeratorCoefficients: Map<List<UInt>, C>, denominatorCoefficients: Map<List<UInt>, C>): NumberedRationalFunction<C> =
- NumberedRationalFunction<C>(
- NumberedPolynomial(numeratorCoefficients, toCheckInput = true),
- NumberedPolynomial(denominatorCoefficients, toCheckInput = true)
- )
-@Suppress("FunctionName")
-public fun <C, A: Ring<C>> NumberedRationalFunctionSpace<C, A>.NumberedRationalFunction(numerator: NumberedPolynomial<C>): NumberedRationalFunction<C> =
- NumberedRationalFunction<C>(numerator, polynomialOne)
-@Suppress("FunctionName")
-public fun <C, A: Ring<C>> A.NumberedRationalFunction(numerator: NumberedPolynomial<C>): NumberedRationalFunction<C> =
- NumberedRationalFunction<C>(numerator, NumberedPolynomial(mapOf(emptyList<UInt>() to one), toCheckInput = false))
-@Suppress("FunctionName")
-public fun <C, A: Ring<C>> NumberedRationalFunctionSpace<C, A>.NumberedRationalFunction(numeratorCoefficients: Map<List<UInt>, C>): NumberedRationalFunction<C> =
- NumberedRationalFunction<C>(
- NumberedPolynomial(numeratorCoefficients, toCheckInput = true),
- polynomialOne
- )
-@Suppress("FunctionName")
-public fun <C, A: Ring<C>> A.NumberedRationalFunction(numeratorCoefficients: Map<List<UInt>, C>): NumberedRationalFunction<C> =
- NumberedRationalFunction<C>(
- NumberedPolynomial(numeratorCoefficients, toCheckInput = true),
- NumberedPolynomial(mapOf(emptyList<UInt>() to one), toCheckInput = false)
- )
-
-//context(A)
-//public fun <C, A: Ring<C>> C.asNumberedRationalFunction() : NumberedRationalFunction<C> = NumberedRationalFunction(asLabeledPolynomial())
-//context(NumberedRationalFunctionSpace<C, A>)
-//public fun <C, A: Ring<C>> C.asNumberedRationalFunction() : NumberedRationalFunction<C> = NumberedRationalFunction(asLabeledPolynomial())
\ No newline at end of file
diff --git a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/numberedPolynomialUtil.kt b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/numberedPolynomialUtil.kt
deleted file mode 100644
index ad817c7ba..000000000
--- a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/numberedPolynomialUtil.kt
+++ /dev/null
@@ -1,528 +0,0 @@
-package space.kscience.kmath.functions
-
-import space.kscience.kmath.misc.UnstableKMathAPI
-import space.kscience.kmath.operations.*
-import kotlin.contracts.*
-import kotlin.jvm.JvmName
-import kotlin.math.max
-
-
-// TODO: Docs
-
-/**
- * Creates a [NumberedPolynomialSpace] over a received ring.
- */
-public fun <C, A : Ring<C>> A.numberedPolynomial(): NumberedPolynomialSpace<C, A> =
- NumberedPolynomialSpace(this)
-
-/**
- * Creates a [NumberedPolynomialSpace]'s scope over a received ring.
- */
-@OptIn(ExperimentalContracts::class)
-public inline fun <C, A : Ring<C>, R> A.numberedPolynomial(block: NumberedPolynomialSpace<C, A>.() -> R): R {
- contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) }
- return NumberedPolynomialSpace(this).block()
-}
-
-///**
-// * Represents the polynomial as a [String] where name of variable with index `i` is [withVariableName] + `"_${i+1}"`.
-// * Consider that monomials are sorted in lexicographic order.
-// */
-//context(NumberedPolynomialSpace<C, A>)
-//public fun <C, A: Ring<C>> NumberedPolynomial<C>.represent(withVariableName: String = NumberedPolynomial.defaultVariableName): String =
-// coefficients.entries
-// .sortedWith { o1, o2 -> NumberedPolynomial.monomialComparator.compare(o1.key, o2.key) }
-// .asSequence()
-// .map { (degs, t) ->
-// if (degs.isEmpty()) "$t"
-// else {
-// when {
-// t.isOne() -> ""
-// t.isMinusOne() -> "-"
-// else -> "$t "
-// } +
-// degs
-// .mapIndexed { index, deg ->
-// when (deg) {
-// 0U -> ""
-// 1U -> "${withVariableName}_${index+1}"
-// else -> "${withVariableName}_${index+1}^$deg"
-// }
-// }
-// .filter { it.isNotEmpty() }
-// .joinToString(separator = " ") { it }
-// }
-// }
-// .joinToString(separator = " + ") { it }
-// .ifEmpty { "0" }
-//
-///**
-// * Represents the polynomial as a [String] naming variables by [namer].
-// * Consider that monomials are sorted in lexicographic order.
-// */
-//context(NumberedPolynomialSpace<C, A>)
-//public fun <C, A: Ring<C>> NumberedPolynomial<C>.represent(namer: (Int) -> String): String =
-// coefficients.entries
-// .sortedWith { o1, o2 -> NumberedPolynomial.monomialComparator.compare(o1.key, o2.key) }
-// .asSequence()
-// .map { (degs, t) ->
-// if (degs.isEmpty()) "$t"
-// else {
-// when {
-// t.isOne() -> ""
-// t.isMinusOne() -> "-"
-// else -> "$t "
-// } +
-// degs
-// .mapIndexed { index, deg ->
-// when (deg) {
-// 0U -> ""
-// 1U -> namer(index)
-// else -> "${namer(index)}^$deg"
-// }
-// }
-// .filter { it.isNotEmpty() }
-// .joinToString(separator = " ") { it }
-// }
-// }
-// .joinToString(separator = " + ") { it }
-// .ifEmpty { "0" }
-//
-///**
-// * Represents the polynomial as a [String] where name of variable with index `i` is [withVariableName] + `"_${i+1}"`
-// * and with brackets around the string if needed (i.e. when there are at least two addends in the representation).
-// * Consider that monomials are sorted in lexicographic order.
-// */
-//context(NumberedPolynomialSpace<C, A>)
-//public fun <C, A: Ring<C>> NumberedPolynomial<C>.representWithBrackets(withVariableName: String = NumberedPolynomial.defaultVariableName): String =
-// with(represent(withVariableName)) { if (coefficients.count() == 1) this else "($this)" }
-//
-///**
-// * Represents the polynomial as a [String] naming variables by [namer] and with brackets around the string if needed
-// * (i.e. when there are at least two addends in the representation).
-// * Consider that monomials are sorted in lexicographic order.
-// */
-//context(NumberedPolynomialSpace<C, A>)
-//public fun <C, A: Ring<C>> NumberedPolynomial<C>.representWithBrackets(namer: (Int) -> String): String =
-// with(represent(namer)) { if (coefficients.count() == 1) this else "($this)" }
-//
-///**
-// * Represents the polynomial as a [String] where name of variable with index `i` is [withVariableName] + `"_${i+1}"`.
-// * Consider that monomials are sorted in **reversed** lexicographic order.
-// */
-//context(NumberedPolynomialSpace<C, A>)
-//public fun <C, A: Ring<C>> NumberedPolynomial<C>.representReversed(withVariableName: String = NumberedPolynomial.defaultVariableName): String =
-// coefficients.entries
-// .sortedWith { o1, o2 -> -NumberedPolynomial.monomialComparator.compare(o1.key, o2.key) }
-// .asSequence()
-// .map { (degs, t) ->
-// if (degs.isEmpty()) "$t"
-// else {
-// when {
-// t.isOne() -> ""
-// t.isMinusOne() -> "-"
-// else -> "$t "
-// } +
-// degs
-// .mapIndexed { index, deg ->
-// when (deg) {
-// 0U -> ""
-// 1U -> "${withVariableName}_${index+1}"
-// else -> "${withVariableName}_${index+1}^$deg"
-// }
-// }
-// .filter { it.isNotEmpty() }
-// .joinToString(separator = " ") { it }
-// }
-// }
-// .joinToString(separator = " + ") { it }
-// .ifEmpty { "0" }
-//
-///**
-// * Represents the polynomial as a [String] naming variables by [namer].
-// * Consider that monomials are sorted in **reversed** lexicographic order.
-// */
-//context(NumberedPolynomialSpace<C, A>)
-//public fun <C, A: Ring<C>> NumberedPolynomial<C>.representReversed(namer: (Int) -> String): String =
-// coefficients.entries
-// .sortedWith { o1, o2 -> -NumberedPolynomial.monomialComparator.compare(o1.key, o2.key) }
-// .asSequence()
-// .map { (degs, t) ->
-// if (degs.isEmpty()) "$t"
-// else {
-// when {
-// t.isOne() -> ""
-// t.isMinusOne() -> "-"
-// else -> "$t "
-// } +
-// degs
-// .mapIndexed { index, deg ->
-// when (deg) {
-// 0U -> ""
-// 1U -> namer(index)
-// else -> "${namer(index)}^$deg"
-// }
-// }
-// .filter { it.isNotEmpty() }
-// .joinToString(separator = " ") { it }
-// }
-// }
-// .joinToString(separator = " + ") { it }
-// .ifEmpty { "0" }
-//
-///**
-// * Represents the polynomial as a [String] where name of variable with index `i` is [withVariableName] + `"_${i+1}"`
-// * and with brackets around the string if needed (i.e. when there are at least two addends in the representation).
-// * Consider that monomials are sorted in **reversed** lexicographic order.
-// */
-//context(NumberedPolynomialSpace<C, A>)
-//public fun <C, A: Ring<C>> NumberedPolynomial<C>.representReversedWithBrackets(withVariableName: String = NumberedPolynomial.defaultVariableName): String =
-// with(representReversed(withVariableName)) { if (coefficients.count() == 1) this else "($this)" }
-//
-///**
-// * Represents the polynomial as a [String] naming variables by [namer] and with brackets around the string if needed
-// * (i.e. when there are at least two addends in the representation).
-// * Consider that monomials are sorted in **reversed** lexicographic order.
-// */
-//context(NumberedPolynomialSpace<C, A>)
-//public fun <C, A: Ring<C>> NumberedPolynomial<C>.representReversedWithBrackets(namer: (Int) -> String): String =
-// with(representReversed(namer)) { if (coefficients.count() == 1) this else "($this)" }
-
-//public fun <C> NumberedPolynomial<C>.substitute(ring: Ring<C>, args: Map<Int, C>): NumberedPolynomial<C> = ring {
-// if (coefficients.isEmpty()) return this@substitute
-// NumberedPolynomial<C>(
-// buildMap {
-// coefficients.forEach { (degs, c) ->
-// val newDegs = degs.mapIndexed { index, deg -> if (index in args) 0U else deg }.cleanUp()
-// val newC = degs.foldIndexed(c) { index, acc, deg ->
-// if (index in args) multiplyWithPower(acc, args[index]!!, deg)
-// else acc
-// }
-// this[newDegs] = if (newDegs in this) this[newDegs]!! + newC else newC
-// }
-// }
-// )
-//}
-//
-//// TODO: Replace with optimisation: the [result] may be unboxed, and all operations may be performed as soon as
-//// possible on it
-//@JvmName("substitutePolynomial")
-//public fun <C> NumberedPolynomial<C>.substitute(ring: Ring<C>, arg: Map<Int, NumberedPolynomial<C>>) : NumberedPolynomial<C> =
-// ring.numberedPolynomialSpace {
-// if (coefficients.isEmpty()) return zero
-// coefficients
-// .asSequence()
-// .map { (degs, c) ->
-// degs.foldIndexed(
-// NumberedPolynomial(
-// degs.mapIndexed { index, deg -> if (index in arg) 0U else deg } to c
-// )
-// ) { index, acc, deg -> if (index in arg) multiplyWithPower(acc, arg[index]!!, deg) else acc }
-// }
-// .reduce { acc, polynomial -> acc + polynomial } // TODO: Rewrite. Might be slow.
-// }
-//
-//// TODO: Substitute rational function
-//
-//public fun <C, A : Ring<C>> NumberedPolynomial<C>.asFunctionOver(ring: A): (Map<Int, C>) -> NumberedPolynomial<C> =
-// { substitute(ring, it) }
-//
-//public fun <C, A : Ring<C>> NumberedPolynomial<C>.asPolynomialFunctionOver(ring: A): (Map<Int, NumberedPolynomial<C>>) -> NumberedPolynomial<C> =
-// { substitute(ring, it) }
-
-//operator fun <T: Field<T>> Polynomial<T>.div(other: T): Polynomial<T> =
-// if (other.isZero()) throw ArithmeticException("/ by zero")
-// else
-// Polynomial(
-// coefficients
-// .mapValues { it.value / other },
-// toCheckInput = false
-// )
-
-/**
- * Evaluates the value of the given double polynomial for given double argument.
- */
-public fun NumberedPolynomial<Double>.substitute(args: Map<Int, Double>): NumberedPolynomial<Double> = Double.algebra {
- val acc = LinkedHashMap<List<UInt>, Double>(coefficients.size)
- for ((degs, c) in coefficients) {
- val newDegs = degs.mapIndexed { index, deg -> if (index !in args) deg else 0u }.cleanUp()
- val newC = args.entries.fold(c) { product, (variable, substitution) ->
- val deg = degs.getOrElse(variable) { 0u }
- if (deg == 0u) product else product * substitution.pow(deg.toInt())
- }
- if (newDegs !in acc) acc[newDegs] = newC
- else acc[newDegs] = acc[newDegs]!! + newC
- }
- return NumberedPolynomial<Double>(acc)
-}
-
-/**
- * Evaluates the value of the given polynomial for given argument.
- *
- * It is an implementation of [Horner's method](https://en.wikipedia.org/wiki/Horner%27s_method).
- */
-public fun <C> NumberedPolynomial<C>.substitute(ring: Ring<C>, args: Map<Int, C>): NumberedPolynomial<C> = ring {
- val acc = LinkedHashMap<List<UInt>, C>(coefficients.size)
- for ((degs, c) in coefficients) {
- val newDegs = degs.mapIndexed { index, deg -> if (index !in args) deg else 0u }.cleanUp()
- val newC = args.entries.fold(c) { product, (variable, substitution) ->
- val deg = degs.getOrElse(variable) { 0u }
- if (deg == 0u) product else product * power(substitution, deg)
- }
- if (newDegs !in acc) acc[newDegs] = newC
- else acc[newDegs] = acc[newDegs]!! + newC
- }
- return NumberedPolynomial<C>(acc)
-}
-
-// TODO: (Waiting for hero) Replace with optimisation: the [result] may be unboxed, and all operations may be performed
-// as soon as possible on it
-@JvmName("substitutePolynomial")
-public fun <C> NumberedPolynomial<C>.substitute(ring: Ring<C>, args: Map<Int, NumberedPolynomial<C>>) : NumberedPolynomial<C> = TODO() /*ring.numberedPolynomial {
- val acc = LinkedHashMap<List<UInt>, NumberedPolynomial<C>>(coefficients.size)
- for ((degs, c) in coefficients) {
- val newDegs = degs.mapIndexed { index, deg -> if (index !in args) deg else 0u }.cleanUp()
- val newC = args.entries.fold(c.asNumberedPolynomial()) { product, (variable, substitution) ->
- val deg = degs.getOrElse(variable) { 0u }
- if (deg == 0u) product else product * power(substitution, deg)
- }
- if (newDegs !in acc) acc[newDegs] = c.asNumberedPolynomial()
- else acc[newDegs] = acc[newDegs]!! + c
- }
-}*/
-
-/**
- * Represent the polynomial as a regular context-less function.
- */
-public fun <C, A : Ring<C>> NumberedPolynomial<C>.asFunction(ring: A): (Map<Int, C>) -> NumberedPolynomial<C> = { substitute(ring, it) }
-
-/**
- * Represent the polynomial as a regular context-less function.
- */
-public fun <C, A : Ring<C>> NumberedPolynomial<C>.asPolynomialFunctionOver(ring: A): (Map<Int, NumberedPolynomial<C>>) -> NumberedPolynomial<C> = { substitute(ring, it) }
-
-/**
- * Returns algebraic derivative of received polynomial.
- */
-@UnstableKMathAPI
-public fun <C, A : Ring<C>> NumberedPolynomial<C>.derivativeWithRespectTo(
- algebra: A,
- variable: Int,
-): NumberedPolynomial<C> = algebra {
- NumberedPolynomial<C>(
- buildMap(coefficients.size) {
- coefficients
- .forEach { (degs, c) ->
- if (degs.size > variable) return@forEach
- put(
- degs.mapIndexed { index, deg ->
- when {
- index != variable -> deg
- deg > 0u -> deg - 1u
- else -> return@forEach
- }
- }.cleanUp(),
- multiplyByDoubling(c, degs[variable])
- )
- }
- }
- )
-}
-
-/**
- * Returns algebraic derivative of received polynomial.
- */
-@UnstableKMathAPI
-public fun <C, A : Ring<C>> NumberedPolynomial<C>.derivativeWithRespectTo(
- algebra: A,
- variables: Collection<Int>,
-): NumberedPolynomial<C> = algebra {
- val cleanedVariables = variables.toSet()
- if (cleanedVariables.isEmpty()) return this@derivativeWithRespectTo
- val maxRespectedVariable = cleanedVariables.maxOrNull()!!
- NumberedPolynomial<C>(
- buildMap(coefficients.size) {
- coefficients
- .forEach { (degs, c) ->
- if (degs.size > maxRespectedVariable) return@forEach
- put(
- degs.mapIndexed { index, deg ->
- when {
- index !in cleanedVariables -> deg
- deg > 0u -> deg - 1u
- else -> return@forEach
- }
- }.cleanUp(),
- cleanedVariables.fold(c) { acc, variable -> multiplyByDoubling(acc, degs[variable]) }
- )
- }
- }
- )
-}
-
-/**
- * Returns algebraic derivative of received polynomial.
- */
-@UnstableKMathAPI
-public fun <C, A : Ring<C>> NumberedPolynomial<C>.nthDerivativeWithRespectTo(
- algebra: A,
- variable: Int,
- order: UInt
-): NumberedPolynomial<C> = algebra {
- if (order == 0u) return this@nthDerivativeWithRespectTo
- NumberedPolynomial<C>(
- buildMap(coefficients.size) {
- coefficients
- .forEach { (degs, c) ->
- if (degs.size > variable) return@forEach
- put(
- degs.mapIndexed { index, deg ->
- when {
- index != variable -> deg
- deg >= order -> deg - order
- else -> return@forEach
- }
- }.cleanUp(),
- degs[variable].let { deg ->
- (deg downTo deg - order + 1u)
- .fold(c) { acc, ord -> multiplyByDoubling(acc, ord) }
- }
- )
- }
- }
- )
-}
-
-/**
- * Returns algebraic derivative of received polynomial.
- */
-@UnstableKMathAPI
-public fun <C, A : Ring<C>> NumberedPolynomial<C>.nthDerivativeWithRespectTo(
- algebra: A,
- variablesAndOrders: Map<Int, UInt>,
-): NumberedPolynomial<C> = algebra {
- val filteredVariablesAndOrders = variablesAndOrders.filterValues { it != 0u }
- if (filteredVariablesAndOrders.isEmpty()) return this@nthDerivativeWithRespectTo
- val maxRespectedVariable = filteredVariablesAndOrders.keys.maxOrNull()!!
- NumberedPolynomial<C>(
- buildMap(coefficients.size) {
- coefficients
- .forEach { (degs, c) ->
- if (degs.size > maxRespectedVariable) return@forEach
- put(
- degs.mapIndexed { index, deg ->
- if (index !in filteredVariablesAndOrders) return@mapIndexed deg
- val order = filteredVariablesAndOrders[index]!!
- if (deg >= order) deg - order else return@forEach
- }.cleanUp(),
- filteredVariablesAndOrders.entries.fold(c) { acc1, (index, order) ->
- degs[index].let { deg ->
- (deg downTo deg - order + 1u)
- .fold(acc1) { acc2, ord -> multiplyByDoubling(acc2, ord) }
- }
- }
- )
- }
- }
- )
-}
-
-/**
- * Returns algebraic antiderivative of received polynomial.
- */
-@UnstableKMathAPI
-public fun <C, A : Field<C>> NumberedPolynomial<C>.antiderivativeWithRespectTo(
- algebra: A,
- variable: Int,
-): NumberedPolynomial<C> = algebra {
- NumberedPolynomial<C>(
- buildMap(coefficients.size) {
- coefficients
- .forEach { (degs, c) ->
- put(
- List(max(variable + 1, degs.size)) { if (it != variable) degs[it] else degs[it] + 1u },
- c / multiplyByDoubling(one, degs[variable])
- )
- }
- }
- )
-}
-
-/**
- * Returns algebraic antiderivative of received polynomial.
- */
-@UnstableKMathAPI
-public fun <C, A : Field<C>> NumberedPolynomial<C>.antiderivativeWithRespectTo(
- algebra: A,
- variables: Collection<Int>,
-): NumberedPolynomial<C> = algebra {
- val cleanedVariables = variables.toSet()
- if (cleanedVariables.isEmpty()) return this@antiderivativeWithRespectTo
- val maxRespectedVariable = cleanedVariables.maxOrNull()!!
- NumberedPolynomial<C>(
- buildMap(coefficients.size) {
- coefficients
- .forEach { (degs, c) ->
- put(
- List(max(maxRespectedVariable + 1, degs.size)) { if (it !in variables) degs[it] else degs[it] + 1u },
- cleanedVariables.fold(c) { acc, variable -> acc / multiplyByDoubling(one, degs[variable]) }
- )
- }
- }
- )
-}
-
-/**
- * Returns algebraic derivative of received polynomial.
- */
-@UnstableKMathAPI
-public fun <C, A : Field<C>> NumberedPolynomial<C>.nthAntiderivativeWithRespectTo(
- algebra: A,
- variable: Int,
- order: UInt
-): NumberedPolynomial<C> = algebra {
- if (order == 0u) return this@nthAntiderivativeWithRespectTo
- NumberedPolynomial<C>(
- buildMap(coefficients.size) {
- coefficients
- .forEach { (degs, c) ->
- put(
- List(max(variable + 1, degs.size)) { if (it != variable) degs[it] else degs[it] + order },
- degs[variable].let { deg ->
- (deg downTo deg - order + 1u)
- .fold(c) { acc, ord -> acc / multiplyByDoubling(one, ord) }
- }
- )
- }
- }
- )
-}
-
-/**
- * Returns algebraic derivative of received polynomial.
- */
-@UnstableKMathAPI
-public fun <C, A : Field<C>> NumberedPolynomial<C>.nthAntiderivativeWithRespectTo(
- algebra: A,
- variablesAndOrders: Map<Int, UInt>,
-): NumberedPolynomial<C> = algebra {
- val filteredVariablesAndOrders = variablesAndOrders.filterValues { it != 0u }
- if (filteredVariablesAndOrders.isEmpty()) return this@nthAntiderivativeWithRespectTo
- val maxRespectedVariable = filteredVariablesAndOrders.keys.maxOrNull()!!
- NumberedPolynomial<C>(
- buildMap(coefficients.size) {
- coefficients
- .forEach { (degs, c) ->
- put(
- List(max(maxRespectedVariable + 1, degs.size)) { degs[it] + filteredVariablesAndOrders.getOrElse(it) { 0u } },
- filteredVariablesAndOrders.entries.fold(c) { acc1, (index, order) ->
- degs[index].let { deg ->
- (deg downTo deg - order + 1u)
- .fold(acc1) { acc2, ord -> acc2 / multiplyByDoubling(one, ord) }
- }
- }
- )
- }
- }
- )
-}
\ No newline at end of file
diff --git a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/numberedRationalFunctionUtil.kt b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/numberedRationalFunctionUtil.kt
deleted file mode 100644
index 5cd0679ab..000000000
--- a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/numberedRationalFunctionUtil.kt
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- * Copyright 2018-2021 KMath contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package space.kscience.kmath.functions
-
-import space.kscience.kmath.operations.Ring
-import kotlin.contracts.InvocationKind
-import kotlin.contracts.contract
-
-
-/**
- * Creates a [NumberedRationalFunctionSpace] over a received ring.
- */
-public fun <C, A : Ring<C>> A.numberedRationalFunction(): NumberedRationalFunctionSpace<C, A> =
- NumberedRationalFunctionSpace(this)
-
-/**
- * Creates a [NumberedRationalFunctionSpace]'s scope over a received ring.
- */
-public inline fun <C, A : Ring<C>, R> A.numberedRationalFunction(block: NumberedRationalFunctionSpace<C, A>.() -> R): R {
- contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) }
- return NumberedRationalFunctionSpace(this).block()
-}
-
-//fun <T: Field<T>> NumberedRationalFunction<T>.reduced(): NumberedRationalFunction<T> {
-// val greatestCommonDivider = polynomialGCD(numerator, denominator)
-// return NumberedRationalFunction(
-// numerator / greatestCommonDivider,
-// denominator / greatestCommonDivider
-// )
-//}
\ No newline at end of file
diff --git a/kmath-functions/src/commonTest/kotlin/space/kscience/kmath/functions/ListPolynomialTest.kt b/kmath-functions/src/commonTest/kotlin/space/kscience/kmath/functions/ListPolynomialTest.kt
index 5401be707..c9950fac5 100644
--- a/kmath-functions/src/commonTest/kotlin/space/kscience/kmath/functions/ListPolynomialTest.kt
+++ b/kmath-functions/src/commonTest/kotlin/space/kscience/kmath/functions/ListPolynomialTest.kt
@@ -12,7 +12,7 @@ import kotlin.test.*
class ListPolynomialTest {
@Test
fun test_Polynomial_Int_plus() {
- RationalField.listPolynomial {
+ RationalField.listPolynomialSpace {
assertEquals(
ListPolynomial(Rational(-22, 9), Rational(-8, 9), Rational(-8, 7)),
ListPolynomial(Rational(5, 9), Rational(-8, 9), Rational(-8, 7)) + -3,
@@ -52,7 +52,7 @@ class ListPolynomialTest {
}
@Test
fun test_Polynomial_Int_minus() {
- RationalField.listPolynomial {
+ RationalField.listPolynomialSpace {
assertEquals(
ListPolynomial(Rational(32, 9), Rational(-8, 9), Rational(-8, 7)),
ListPolynomial(Rational(5, 9), Rational(-8, 9), Rational(-8, 7)) - -3,
@@ -92,7 +92,7 @@ class ListPolynomialTest {
}
@Test
fun test_Polynomial_Int_times() {
- IntModuloRing(35).listPolynomial {
+ IntModuloRing(35).listPolynomialSpace {
assertEquals(
ListPolynomial(34, 2, 1, 20, 2),
ListPolynomial(22, 26, 13, 15, 26) * 27,
@@ -107,7 +107,7 @@ class ListPolynomialTest {
}
@Test
fun test_Int_Polynomial_plus() {
- RationalField.listPolynomial {
+ RationalField.listPolynomialSpace {
assertEquals(
ListPolynomial(Rational(-22, 9), Rational(-8, 9), Rational(-8, 7)),
-3 + ListPolynomial(Rational(5, 9), Rational(-8, 9), Rational(-8, 7)),
@@ -147,7 +147,7 @@ class ListPolynomialTest {
}
@Test
fun test_Int_Polynomial_minus() {
- RationalField.listPolynomial {
+ RationalField.listPolynomialSpace {
assertEquals(
ListPolynomial(Rational(32, 9), Rational(-8, 9), Rational(-8, 7)),
3 - ListPolynomial(Rational(-5, 9), Rational(8, 9), Rational(8, 7)),
@@ -187,7 +187,7 @@ class ListPolynomialTest {
}
@Test
fun test_Int_Polynomial_times() {
- IntModuloRing(35).listPolynomial {
+ IntModuloRing(35).listPolynomialSpace {
assertEquals(
ListPolynomial(34, 2, 1, 20, 2),
27 * ListPolynomial(22, 26, 13, 15, 26),
@@ -202,7 +202,7 @@ class ListPolynomialTest {
}
@Test
fun test_Polynomial_Constant_plus() {
- RationalField.listPolynomial {
+ RationalField.listPolynomialSpace {
assertEquals(
ListPolynomial(Rational(-22, 9), Rational(-8, 9), Rational(-8, 7)),
ListPolynomial(Rational(5, 9), Rational(-8, 9), Rational(-8, 7)) + Rational(-3),
@@ -242,7 +242,7 @@ class ListPolynomialTest {
}
@Test
fun test_Polynomial_Constant_minus() {
- RationalField.listPolynomial {
+ RationalField.listPolynomialSpace {
assertEquals(
ListPolynomial(Rational(32, 9), Rational(-8, 9), Rational(-8, 7)),
ListPolynomial(Rational(5, 9), Rational(-8, 9), Rational(-8, 7)) - Rational(-3),
@@ -282,7 +282,7 @@ class ListPolynomialTest {
}
@Test
fun test_Polynomial_Constant_times() {
- IntModuloRing(35).listPolynomial {
+ IntModuloRing(35).listPolynomialSpace {
assertEquals(
ListPolynomial(34, 2, 1, 20, 2),
ListPolynomial(22, 26, 13, 15, 26) * 27.asConstant(),
@@ -297,7 +297,7 @@ class ListPolynomialTest {
}
@Test
fun test_Constant_Polynomial_plus() {
- RationalField.listPolynomial {
+ RationalField.listPolynomialSpace {
assertEquals(
ListPolynomial(Rational(-22, 9), Rational(-8, 9), Rational(-8, 7)),
Rational(-3) + ListPolynomial(Rational(5, 9), Rational(-8, 9), Rational(-8, 7)),
@@ -337,7 +337,7 @@ class ListPolynomialTest {
}
@Test
fun test_Constant_Polynomial_minus() {
- RationalField.listPolynomial {
+ RationalField.listPolynomialSpace {
assertEquals(
ListPolynomial(Rational(32, 9), Rational(-8, 9), Rational(-8, 7)),
Rational(3) - ListPolynomial(Rational(-5, 9), Rational(8, 9), Rational(8, 7)),
@@ -377,7 +377,7 @@ class ListPolynomialTest {
}
@Test
fun test_Constant_Polynomial_times() {
- IntModuloRing(35).listPolynomial {
+ IntModuloRing(35).listPolynomialSpace {
assertEquals(
ListPolynomial(34, 2, 1, 20, 2),
27 * ListPolynomial(22, 26, 13, 15, 26),
@@ -392,7 +392,7 @@ class ListPolynomialTest {
}
@Test
fun test_Polynomial_unaryMinus() {
- RationalField.listPolynomial {
+ RationalField.listPolynomialSpace {
assertEquals(
ListPolynomial(Rational(-5, 9), Rational(8, 9), Rational(8, 7)),
-ListPolynomial(Rational(5, 9), Rational(-8, 9), Rational(-8, 7)),
@@ -407,7 +407,7 @@ class ListPolynomialTest {
}
@Test
fun test_Polynomial_Polynomial_plus() {
- RationalField.listPolynomial {
+ RationalField.listPolynomialSpace {
// (5/9 - 8/9 x - 8/7 x^2) + (-5/7 + 5/1 x + 5/8 x^2) ?= -10/63 + 37/9 x - 29/56 x^2
assertEquals(
ListPolynomial(Rational(-10, 63), Rational(37, 9), Rational(-29, 56)),
@@ -440,7 +440,7 @@ class ListPolynomialTest {
}
@Test
fun test_Polynomial_Polynomial_minus() {
- RationalField.listPolynomial {
+ RationalField.listPolynomialSpace {
// (5/9 - 8/9 x - 8/7 x^2) - (-5/7 + 5/1 x + 5/8 x^2) ?= 80/63 - 53/9 x - 99/56 x^2
assertEquals(
ListPolynomial(Rational(80, 63), Rational(-53, 9), Rational(-99, 56)),
@@ -473,7 +473,7 @@ class ListPolynomialTest {
}
@Test
fun test_Polynomial_Polynomial_times() {
- IntModuloRing(35).listPolynomial {
+ IntModuloRing(35).listPolynomialSpace {
// (1 + x + x^2) * (1 - x + x^2) ?= 1 + x^2 + x^4
assertEquals(
ListPolynomial(1, 0, 1, 0, 1),
diff --git a/kmath-functions/src/commonTest/kotlin/space/kscience/kmath/functions/ListPolynomialUtilTest.kt b/kmath-functions/src/commonTest/kotlin/space/kscience/kmath/functions/ListPolynomialUtilTest.kt
index c5eb8fb81..69c1611f3 100644
--- a/kmath-functions/src/commonTest/kotlin/space/kscience/kmath/functions/ListPolynomialUtilTest.kt
+++ b/kmath-functions/src/commonTest/kotlin/space/kscience/kmath/functions/ListPolynomialUtilTest.kt
@@ -5,6 +5,7 @@
package space.kscience.kmath.functions
+import space.kscience.kmath.misc.UnstableKMathAPI
import space.kscience.kmath.test.misc.Rational
import space.kscience.kmath.test.misc.RationalField
import kotlin.test.Test
@@ -12,6 +13,7 @@ import kotlin.test.assertEquals
import kotlin.test.assertFailsWith
+@OptIn(UnstableKMathAPI::class)
class ListPolynomialUtilTest {
@Test
fun test_substitute_Double() {
diff --git a/kmath-functions/src/commonTest/kotlin/space/kscience/kmath/test/misc/IntModulo.kt b/kmath-functions/src/commonTest/kotlin/space/kscience/kmath/test/misc/IntModulo.kt
new file mode 100644
index 000000000..89764db46
--- /dev/null
+++ b/kmath-functions/src/commonTest/kotlin/space/kscience/kmath/test/misc/IntModulo.kt
@@ -0,0 +1,138 @@
+/*
+ * Copyright 2018-2021 KMath contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package space.kscience.kmath.test.misc
+
+import space.kscience.kmath.functions.ListPolynomial
+import space.kscience.kmath.functions.ListPolynomialSpace
+import space.kscience.kmath.operations.Ring
+
+
+class IntModulo {
+ val residue: Int
+ val modulus: Int
+
+ @PublishedApi
+ internal constructor(residue: Int, modulus: Int, toCheckInput: Boolean = true) {
+ if (toCheckInput) {
+ require(modulus != 0) { "modulus can not be zero" }
+ this.modulus = if (modulus < 0) -modulus else modulus
+ this.residue = residue.mod(modulus)
+ } else {
+ this.residue = residue
+ this.modulus = modulus
+ }
+ }
+
+ constructor(residue: Int, modulus: Int) : this(residue, modulus, true)
+
+ operator fun unaryPlus(): IntModulo = this
+ operator fun unaryMinus(): IntModulo =
+ IntModulo(
+ if (residue == 0) 0 else modulus - residue,
+ modulus,
+ toCheckInput = false
+ )
+ operator fun plus(other: IntModulo): IntModulo {
+ require(modulus == other.modulus) { "can not add two residue different modulo" }
+ return IntModulo(
+ (residue + other.residue) % modulus,
+ modulus,
+ toCheckInput = false
+ )
+ }
+ operator fun plus(other: Int): IntModulo =
+ IntModulo(
+ (residue + other) % modulus,
+ modulus,
+ toCheckInput = false
+ )
+ operator fun minus(other: IntModulo): IntModulo {
+ require(modulus == other.modulus) { "can not subtract two residue different modulo" }
+ return IntModulo(
+ (residue - other.residue) % modulus,
+ modulus,
+ toCheckInput = false
+ )
+ }
+ operator fun minus(other: Int): IntModulo =
+ IntModulo(
+ (residue - other) % modulus,
+ modulus,
+ toCheckInput = false
+ )
+ operator fun times(other: IntModulo): IntModulo {
+ require(modulus == other.modulus) { "can not multiply two residue different modulo" }
+ return IntModulo(
+ (residue * other.residue) % modulus,
+ modulus,
+ toCheckInput = false
+ )
+ }
+ operator fun times(other: Int): IntModulo =
+ IntModulo(
+ (residue * other) % modulus,
+ modulus,
+ toCheckInput = false
+ )
+ operator fun div(other: IntModulo): IntModulo {
+ require(modulus == other.modulus) { "can not divide two residue different modulo" }
+ val (reciprocalCandidate, gcdOfOtherResidueAndModulus) = bezoutIdentityWithGCD(other.residue, modulus)
+ require(gcdOfOtherResidueAndModulus == 1) { "can not divide to residue that has non-trivial GCD with modulo" }
+ return IntModulo(
+ (residue * reciprocalCandidate) % modulus,
+ modulus,
+ toCheckInput = false
+ )
+ }
+ operator fun div(other: Int): IntModulo {
+ val (reciprocalCandidate, gcdOfOtherResidueAndModulus) = bezoutIdentityWithGCD(other, modulus)
+ require(gcdOfOtherResidueAndModulus == 1) { "can not divide to residue that has non-trivial GCD with modulo" }
+ return IntModulo(
+ (residue * reciprocalCandidate) % modulus,
+ modulus,
+ toCheckInput = false
+ )
+ }
+ override fun equals(other: Any?): Boolean =
+ when (other) {
+ is IntModulo -> residue == other.residue && modulus == other.modulus
+ else -> false
+ }
+
+ override fun hashCode(): Int = residue.hashCode()
+
+ override fun toString(): String = "$residue mod $modulus"
+}
+
+@Suppress("EXTENSION_SHADOWED_BY_MEMBER", "OVERRIDE_BY_INLINE", "NOTHING_TO_INLINE")
+class IntModuloRing : Ring<IntModulo> {
+
+ val modulus: Int
+
+ constructor(modulus: Int) {
+ require(modulus != 0) { "modulus can not be zero" }
+ this.modulus = if (modulus < 0) -modulus else modulus
+ }
+
+ override inline val zero: IntModulo get() = IntModulo(0, modulus, toCheckInput = false)
+ override inline val one: IntModulo get() = IntModulo(1, modulus, toCheckInput = false)
+
+ fun number(arg: Int) = IntModulo(arg, modulus, toCheckInput = false)
+
+ override inline fun add(left: IntModulo, right: IntModulo): IntModulo = left + right
+ override inline fun multiply(left: IntModulo, right: IntModulo): IntModulo = left * right
+
+ override inline fun IntModulo.unaryMinus(): IntModulo = -this
+ override inline fun IntModulo.plus(arg: IntModulo): IntModulo = this + arg
+ override inline fun IntModulo.minus(arg: IntModulo): IntModulo = this - arg
+ override inline fun IntModulo.times(arg: IntModulo): IntModulo = this * arg
+ inline fun IntModulo.div(arg: IntModulo): IntModulo = this / arg
+}
+
+fun ListPolynomialSpace<IntModulo, IntModuloRing>.ListPolynomial(vararg coefs: Int): ListPolynomial<IntModulo> =
+ ListPolynomial(coefs.map { IntModulo(it, ring.modulus) })
+fun IntModuloRing.ListPolynomial(vararg coefs: Int): ListPolynomial<IntModulo> =
+ ListPolynomial(coefs.map { IntModulo(it, modulus) })
\ No newline at end of file
diff --git a/kmath-functions/src/commonTest/kotlin/space/kscience/kmath/test/misc/Rational.kt b/kmath-functions/src/commonTest/kotlin/space/kscience/kmath/test/misc/Rational.kt
new file mode 100644
index 000000000..72bb5942c
--- /dev/null
+++ b/kmath-functions/src/commonTest/kotlin/space/kscience/kmath/test/misc/Rational.kt
@@ -0,0 +1,135 @@
+/*
+ * Copyright 2018-2021 KMath contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package space.kscience.kmath.test.misc
+
+import space.kscience.kmath.misc.UnstableKMathAPI
+import space.kscience.kmath.operations.Field
+import space.kscience.kmath.operations.NumbersAddOps
+
+class Rational {
+ companion object {
+ val ZERO: Rational = Rational(0L)
+ val ONE: Rational = Rational(1L)
+ }
+
+ val numerator: Long
+ val denominator: Long
+
+ internal constructor(numerator: Long, denominator: Long, toCheckInput: Boolean = true) {
+ if (toCheckInput) {
+ if (denominator == 0L) throw ArithmeticException("/ by zero")
+
+ val greatestCommonDivider = gcd(numerator, denominator).let { if (denominator < 0L) -it else it }
+
+ this.numerator = numerator / greatestCommonDivider
+ this.denominator = denominator / greatestCommonDivider
+ } else {
+ this.numerator = numerator
+ this.denominator = denominator
+ }
+ }
+
+ constructor(numerator: Int, denominator: Int) : this(numerator.toLong(), denominator.toLong(), true)
+ constructor(numerator: Int, denominator: Long) : this(numerator.toLong(), denominator, true)
+ constructor(numerator: Long, denominator: Int) : this(numerator, denominator.toLong(), true)
+ constructor(numerator: Long, denominator: Long) : this(numerator, denominator, true)
+ constructor(numerator: Int) : this(numerator.toLong(), 1L, false)
+ constructor(numerator: Long) : this(numerator, 1L, false)
+
+ operator fun unaryPlus(): Rational = this
+ operator fun unaryMinus(): Rational = Rational(-this.numerator, this.denominator)
+ operator fun plus(other: Rational): Rational =
+ Rational(
+ numerator * other.denominator + denominator * other.numerator,
+ denominator * other.denominator
+ )
+ operator fun plus(other: Int): Rational =
+ Rational(
+ numerator + denominator * other.toLong(),
+ denominator
+ )
+ operator fun plus(other: Long): Rational =
+ Rational(
+ numerator + denominator * other,
+ denominator
+ )
+ operator fun minus(other: Rational): Rational =
+ Rational(
+ numerator * other.denominator - denominator * other.numerator,
+ denominator * other.denominator
+ )
+ operator fun minus(other: Int): Rational =
+ Rational(
+ numerator - denominator * other.toLong(),
+ denominator
+ )
+ operator fun minus(other: Long): Rational =
+ Rational(
+ numerator - denominator * other,
+ denominator
+ )
+ operator fun times(other: Rational): Rational =
+ Rational(
+ numerator * other.numerator,
+ denominator * other.denominator
+ )
+ operator fun times(other: Int): Rational =
+ Rational(
+ numerator * other.toLong(),
+ denominator
+ )
+ operator fun times(other: Long): Rational =
+ Rational(
+ numerator * other,
+ denominator
+ )
+ operator fun div(other: Rational): Rational =
+ Rational(
+ numerator * other.denominator,
+ denominator * other.numerator
+ )
+ operator fun div(other: Int): Rational =
+ Rational(
+ numerator,
+ denominator * other.toLong()
+ )
+ operator fun div(other: Long): Rational =
+ Rational(
+ numerator,
+ denominator * other
+ )
+ override fun equals(other: Any?): Boolean =
+ when (other) {
+ is Rational -> numerator == other.numerator && denominator == other.denominator
+ is Int -> numerator == other && denominator == 1L
+ is Long -> numerator == other && denominator == 1L
+ else -> false
+ }
+
+ override fun hashCode(): Int = 31 * numerator.hashCode() + denominator.hashCode()
+
+ override fun toString(): String = if (denominator == 1L) "$numerator" else "$numerator/$denominator"
+}
+
+@Suppress("EXTENSION_SHADOWED_BY_MEMBER", "OVERRIDE_BY_INLINE", "NOTHING_TO_INLINE")
+@OptIn(UnstableKMathAPI::class)
+object RationalField : Field<Rational>, NumbersAddOps<Rational> {
+ override inline val zero: Rational get() = Rational.ZERO
+ override inline val one: Rational get() = Rational.ONE
+
+ override inline fun number(value: Number): Rational = Rational(value.toLong())
+
+ override inline fun add(left: Rational, right: Rational): Rational = left + right
+ override inline fun multiply(left: Rational, right: Rational): Rational = left * right
+ override inline fun divide(left: Rational, right: Rational): Rational = left / right
+ override inline fun scale(a: Rational, value: Double): Rational = a * number(value)
+
+ override inline fun Rational.unaryMinus(): Rational = -this
+ override inline fun Rational.plus(arg: Rational): Rational = this + arg
+ override inline fun Rational.minus(arg: Rational): Rational = this - arg
+ override inline fun Rational.times(arg: Rational): Rational = this * arg
+ override inline fun Rational.div(arg: Rational): Rational = this / arg
+}
\ No newline at end of file
diff --git a/kmath-functions/src/commonTest/kotlin/space/kscience/kmath/test/misc/misc.kt b/kmath-functions/src/commonTest/kotlin/space/kscience/kmath/test/misc/misc.kt
new file mode 100644
index 000000000..ed41b9245
--- /dev/null
+++ b/kmath-functions/src/commonTest/kotlin/space/kscience/kmath/test/misc/misc.kt
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2018-2021 KMath contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package space.kscience.kmath.test.misc
+
+import kotlin.math.abs
+
+
+data class BezoutIdentityWithGCD<T>(val first: T, val second: T, val gcd: T)
+
+tailrec fun gcd(a: Long, b: Long): Long = if (a == 0L) abs(b) else gcd(b % a, a)
+
+fun bezoutIdentityWithGCD(a: Int, b: Int): BezoutIdentityWithGCD<Int> =
+ when {
+ a < 0 && b < 0 -> with(bezoutIdentityWithGCDInternalLogic(-a, -b, 1, 0, 0, 1)) { BezoutIdentityWithGCD(-first, -second, gcd) }
+ a < 0 -> with(bezoutIdentityWithGCDInternalLogic(-a, b, 1, 0, 0, 1)) { BezoutIdentityWithGCD(-first, second, gcd) }
+ b < 0 -> with(bezoutIdentityWithGCDInternalLogic(a, -b, 1, 0, 0, 1)) { BezoutIdentityWithGCD(first, -second, gcd) }
+ else -> bezoutIdentityWithGCDInternalLogic(a, b, 1, 0, 0, 1)
+ }
+
+internal tailrec fun bezoutIdentityWithGCDInternalLogic(a: Int, b: Int, m1: Int, m2: Int, m3: Int, m4: Int): BezoutIdentityWithGCD<Int> =
+ if (b == 0) BezoutIdentityWithGCD(m1, m3, a)
+ else {
+ val quotient = a / b
+ val reminder = a % b
+ bezoutIdentityWithGCDInternalLogic(b, reminder, m2, m1 - quotient * m2, m4, m3 - quotient * m4)
+ }
\ No newline at end of file