kone.polynomial/com.lounres.kone.polynomial

Package-level declarations

Types

typealias DefaultLabeledRationalFunctionSpace<C, A> = LabeledRationalFunctionSpace<C, A, LabeledPolynomialSpace<C, A>>

DefaultLabeledRationalFunctionSpaceOverField

typealias DefaultLabeledRationalFunctionSpaceOverField<C, A> = LabeledRationalFunctionSpaceOverField<C, A, LabeledPolynomialSpaceOverField<C, A>>

DefaultListRationalFunctionSpace

typealias DefaultListRationalFunctionSpace<C, A> = ListRationalFunctionSpace<C, A, ListPolynomialSpace<C, A>>

DefaultListRationalFunctionSpaceOverField

typealias DefaultListRationalFunctionSpaceOverField<C, A> = ListRationalFunctionSpaceOverField<C, A, ListPolynomialSpaceOverField<C, A>>

DefaultNumberedRationalFunctionSpace

typealias DefaultNumberedRationalFunctionSpace<C, A> = NumberedRationalFunctionSpace<C, A, NumberedPolynomialSpace<C, A>>

DefaultNumberedRationalFunctionSpaceOverField

typealias DefaultNumberedRationalFunctionSpaceOverField<C, A> = NumberedRationalFunctionSpaceOverField<C, A, NumberedPolynomialSpaceOverField<C, A>>

DelicatePolynomialAPI

@Target(allowedTargets = [AnnotationTarget.CLASS, AnnotationTarget.ANNOTATION_CLASS, AnnotationTarget.PROPERTY, AnnotationTarget.FIELD, AnnotationTarget.LOCAL_VARIABLE, AnnotationTarget.VALUE_PARAMETER, AnnotationTarget.CONSTRUCTOR, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER, AnnotationTarget.TYPEALIAS])

annotation class DelicatePolynomialAPI

Marks declarations that give access to internal entities of polynomials delicate structure. Thus, it allows optimizing performance a bit by skipping standard steps, but such skips may cause critical errors if something is implemented badly. Make sure you fully read and understand documentation and don't break internal contracts.

DSL1LabeledPolynomialBuilder

@ExperimentalKoneAPI

class DSL1LabeledPolynomialBuilder<C>(add: (C, C) -> C, initialCapacity: Int? = null)

DSL1LabeledPolynomialTermSignatureBuilder

@ExperimentalKoneAPI

class DSL1LabeledPolynomialTermSignatureBuilder

DSL1NumberedPolynomialBuilder

@ExperimentalKoneAPI

class DSL1NumberedPolynomialBuilder<C>(add: (C, C) -> C, initialCapacity: Int? = null)

DSL1NumberedPolynomialTermSignatureBuilder

@ExperimentalKoneAPI

class DSL1NumberedPolynomialTermSignatureBuilder

DSL2LabeledPolynomialBuilder

@ExperimentalKoneAPI

class DSL2LabeledPolynomialBuilder<C>(ring: Ring<C>, initialCapacity: Int? = null)

LabeledMonomialSignature

typealias LabeledMonomialSignature = Map<Symbol, UInt>

LabeledPolynomial

data class LabeledPolynomial<C> : Polynomial<C>

LabeledPolynomialCoefficients

typealias LabeledPolynomialCoefficients<C> = Map<LabeledMonomialSignature, C>

LabeledPolynomialSpace

open class LabeledPolynomialSpace<C, out A : Ring<C>>(val ring: A) : MultivariatePolynomialSpace<C, Symbol, LabeledPolynomial<C>> , PolynomialSpaceWithRing<C, LabeledPolynomial<C>, A>

LabeledPolynomialSpaceOverField

class LabeledPolynomialSpaceOverField<C, out A : Field<C>>(ring: A) : LabeledPolynomialSpace<C, A> , MultivariatePolynomialSpaceOverField<C, Symbol, LabeledPolynomial<C>> , PolynomialSpaceWithField<C, LabeledPolynomial<C>, A>

LabeledRationalFunction

data class LabeledRationalFunction<C>(val numerator: LabeledPolynomial<C>, val denominator: LabeledPolynomial<C>) : RationalFunction<C, LabeledPolynomial<C>>

LabeledRationalFunctionSpace

open class LabeledRationalFunctionSpace<C, out A : Ring<C>, out PS : LabeledPolynomialSpace<C, A>>(val polynomialRing: PS) : MultivariatePolynomialSpaceOfFractions<C, Symbol, LabeledPolynomial<C>, LabeledRationalFunction<C>> , MultivariateRationalFunctionSpaceWithMultivariatePolynomialSpace<C, Symbol, LabeledPolynomial<C>, LabeledRationalFunction<C>, PS>

LabeledRationalFunctionSpaceOverField

class LabeledRationalFunctionSpaceOverField<C, out A : Field<C>, out PS : LabeledPolynomialSpaceOverField<C, A>>(polynomialRing: PS) : LabeledRationalFunctionSpace<C, A, PS> , MultivariateRationalFunctionSpaceWithMultivariatePolynomialSpaceOverField<C, Symbol, LabeledPolynomial<C>, LabeledRationalFunction<C>, PS>

ListPolynomial

data class ListPolynomial<C>(val coefficients: List<C>) : Polynomial<C>

ListPolynomialSpace

open class ListPolynomialSpace<C, out A : Ring<C>>(val ring: A) : PolynomialSpaceWithRing<C, ListPolynomial<C>, A>

ListPolynomialSpaceOverField

class ListPolynomialSpaceOverField<C, out A : Field<C>>(ring: A) : ListPolynomialSpace<C, A> , PolynomialSpaceWithField<C, ListPolynomial<C>, A>

ListRationalFunction

data class ListRationalFunction<C>(val numerator: ListPolynomial<C>, val denominator: ListPolynomial<C>) : RationalFunction<C, ListPolynomial<C>>

Represents univariate rational function that stores its numerator and denominator as ListPolynomials.

ListRationalFunctionSpace

open class ListRationalFunctionSpace<C, out A : Ring<C>, out PS : ListPolynomialSpace<C, A>>(val polynomialRing: PS) : PolynomialSpaceOfFractions<C, ListPolynomial<C>, ListRationalFunction<C>> , RationalFunctionSpaceWithPolynomialSpace<C, ListPolynomial<C>, ListRationalFunction<C>, PS>

Arithmetic context for univariate rational functions with numerator and denominator represented as ListPolynomials.

ListRationalFunctionSpaceOverField

class ListRationalFunctionSpaceOverField<C, out A : Field<C>, out PS : ListPolynomialSpaceOverField<C, A>>(polynomialRing: PS) : ListRationalFunctionSpace<C, A, PS> , RationalFunctionSpaceWithPolynomialSpaceOverField<C, ListPolynomial<C>, ListRationalFunction<C>, PS>

MultivariatePolynomialSpace

interface MultivariatePolynomialSpace<C, V, P : Polynomial<C>> : PolynomialSpace<C, P>

MultivariatePolynomialSpaceOfFractions

abstract class MultivariatePolynomialSpaceOfFractions<C, V, P : Polynomial<C>, RF : RationalFunction<C, P>> : PolynomialSpaceOfFractions<C, P, RF> , MultivariateRationalFunctionSpace<C, V, P, RF>

MultivariatePolynomialSpaceOverField

interface MultivariatePolynomialSpaceOverField<C, V, P : Polynomial<C>> : PolynomialSpaceOverField<C, P> , MultivariatePolynomialSpace<C, V, P>

MultivariateRationalFunctionSpace

interface MultivariateRationalFunctionSpace<C, V, P : Polynomial<C>, RF : RationalFunction<C, P>> : RationalFunctionSpace<C, P, RF>

MultivariateRationalFunctionSpaceOverField

interface MultivariateRationalFunctionSpaceOverField<C, V, P : Polynomial<C>, RF : RationalFunction<C, P>> : RationalFunctionSpaceOverField<C, P, RF> , MultivariateRationalFunctionSpace<C, V, P, RF>

MultivariateRationalFunctionSpaceWithMultivariatePolynomialSpace

interface MultivariateRationalFunctionSpaceWithMultivariatePolynomialSpace<C, V, P : Polynomial<C>, RF : RationalFunction<C, P>, out PS : MultivariatePolynomialSpace<C, V, P>> : RationalFunctionSpaceWithPolynomialSpace<C, P, RF, PS> , MultivariateRationalFunctionSpace<C, V, P, RF>

MultivariateRationalFunctionSpaceWithMultivariatePolynomialSpaceOverField

NumberedMonomialSignature

typealias NumberedMonomialSignature = List<UInt>

NumberedPolynomial

data class NumberedPolynomial<C> : Polynomial<C>

NumberedPolynomialCoefficients

typealias NumberedPolynomialCoefficients<C> = Map<NumberedMonomialSignature, C>

NumberedPolynomialSpace

open class NumberedPolynomialSpace<C, out A : Ring<C>>(val ring: A) : PolynomialSpaceWithRing<C, NumberedPolynomial<C>, A>

NumberedPolynomialSpaceOverField

class NumberedPolynomialSpaceOverField<C, out A : Field<C>>(ring: A) : NumberedPolynomialSpace<C, A> , PolynomialSpaceWithField<C, NumberedPolynomial<C>, A>

NumberedRationalFunction

data class NumberedRationalFunction<C>(val numerator: NumberedPolynomial<C>, val denominator: NumberedPolynomial<C>) : RationalFunction<C, NumberedPolynomial<C>>

NumberedRationalFunctionSpace

open class NumberedRationalFunctionSpace<C, out A : Ring<C>, out PS : NumberedPolynomialSpace<C, A>>(val polynomialRing: PS) : PolynomialSpaceOfFractions<C, NumberedPolynomial<C>, NumberedRationalFunction<C>> , RationalFunctionSpaceWithPolynomialSpace<C, NumberedPolynomial<C>, NumberedRationalFunction<C>, PS>

NumberedRationalFunctionSpaceOverField

class NumberedRationalFunctionSpaceOverField<C, out A : Field<C>, out PS : NumberedPolynomialSpaceOverField<C, A>>(polynomialRing: PS) : NumberedRationalFunctionSpace<C, A, PS> , RationalFunctionSpaceWithPolynomialSpace<C, NumberedPolynomial<C>, NumberedRationalFunction<C>, PS>

Polynomial

interface Polynomial<C>

PolynomialSpace

interface PolynomialSpace<C, P : Polynomial<C>> : Ring<P>

PolynomialSpaceOfFractions

abstract class PolynomialSpaceOfFractions<C, P : Polynomial<C>, RF : RationalFunction<C, P>> : RationalFunctionSpace<C, P, RF>

PolynomialSpaceOverField

interface PolynomialSpaceOverField<C, P : Polynomial<C>> : PolynomialSpace<C, P>

PolynomialSpaceWithField

interface PolynomialSpaceWithField<C, P : Polynomial<C>, out A : Field<C>> : PolynomialSpaceOverField<C, P> , PolynomialSpaceWithRing<C, P, A>

PolynomialSpaceWithRing

interface PolynomialSpaceWithRing<C, P : Polynomial<C>, out A : Ring<C>> : PolynomialSpace<C, P>

RationalFunction

interface RationalFunction<C, P : Polynomial<C>>

RationalFunctionSpace

interface RationalFunctionSpace<C, P : Polynomial<C>, RF : RationalFunction<C, P>> : Field<RF>

RationalFunctionSpaceOverField

interface RationalFunctionSpaceOverField<C, P : Polynomial<C>, RF : RationalFunction<C, P>> : RationalFunctionSpace<C, P, RF>

RationalFunctionSpaceWithPolynomialSpace

interface RationalFunctionSpaceWithPolynomialSpace<C, P : Polynomial<C>, RF : RationalFunction<C, P>, out PS : PolynomialSpace<C, P>> : RationalFunctionSpace<C, P, RF>

RationalFunctionSpaceWithPolynomialSpaceOverField

interface RationalFunctionSpaceWithPolynomialSpaceOverField<C, P : Polynomial<C>, RF : RationalFunction<C, P>, out PS : PolynomialSpaceOverField<C, P>> : RationalFunctionSpaceOverField<C, P, RF> , RationalFunctionSpaceWithPolynomialSpace<C, P, RF, PS>

Properties

labeledPolynomialSpace

val <C, A : Field<C>> A.labeledPolynomialSpace: LabeledPolynomialSpaceOverField<C, A>

val <C, A : Ring<C>> A.labeledPolynomialSpace: LabeledPolynomialSpace<C, A>

labeledRationalFunctionSpace

val <C, A : Field<C>> A.labeledRationalFunctionSpace: DefaultLabeledRationalFunctionSpaceOverField<C, A>

val <C, A : Ring<C>> A.labeledRationalFunctionSpace: DefaultLabeledRationalFunctionSpace<C, A>

listPolynomialSpace

val <C, A : Field<C>> A.listPolynomialSpace: ListPolynomialSpaceOverField<C, A>

Creates a ListPolynomialSpaceOverField over a received field.

val <C, A : Ring<C>> A.listPolynomialSpace: ListPolynomialSpace<C, A>

Creates a ListPolynomialSpace over a received ring.

listRationalFunctionSpace

val <C, A : Field<C>> A.listRationalFunctionSpace: DefaultListRationalFunctionSpaceOverField<C, A>

Creates a ListRationalFunctionSpaceOverField over a received field.

val <C, A : Ring<C>> A.listRationalFunctionSpace: DefaultListRationalFunctionSpace<C, A>

Creates a ListRationalFunctionSpace over a received ring.

numberedPolynomialSpace

val <C, A : Field<C>> A.numberedPolynomialSpace: NumberedPolynomialSpaceOverField<C, A>

val <C, A : Ring<C>> A.numberedPolynomialSpace: NumberedPolynomialSpace<C, A>

numberedRationalFunctionSpace

val <C, A : Field<C>> A.numberedRationalFunctionSpace: DefaultNumberedRationalFunctionSpaceOverField<C, A>

val <C, A : Ring<C>> A.numberedRationalFunctionSpace: DefaultNumberedRationalFunctionSpace<C, A>

Functions

antiderivative

@UnstableKoneAPI

fun <C, A : Field<C>> ListPolynomial<C>.antiderivative(ring: A): ListPolynomial<C>

Returns algebraic antiderivative of received polynomial.

antiderivativeWithRespectTo

@ExperimentalKoneAPI

fun <C> LabeledPolynomial<C>.antiderivativeWithRespectTo(algebra: Field<C>, variable: Symbol): LabeledPolynomial<C>

@ExperimentalKoneAPI

fun <C> NumberedPolynomial<C>.antiderivativeWithRespectTo(ring: Field<C>, variable: Int): NumberedPolynomial<C>

asFunctionOfConstantOver

fun <C> ListPolynomial<C>.asFunctionOfConstantOver(ring: Ring<C>): (C) -> C

Represent this polynomial as a regular context-less function.

fun <C> ListRationalFunction<C>.asFunctionOfConstantOver(ring: Field<C>): (C) -> C

Represent this rational function as a regular context-less function.

fun <C> NumberedPolynomial<C>.asFunctionOfConstantOver(ring: Ring<C>): (Buffer<C>) -> C

fun <C> NumberedRationalFunction<C>.asFunctionOfConstantOver(ring: Field<C>): (Buffer<C>) -> C

asFunctionOfPolynomialOver

fun <C> ListPolynomial<C>.asFunctionOfPolynomialOver(ring: Ring<C>): (ListPolynomial<C>) -> ListPolynomial<C>

Represent this polynomial as a regular context-less function.

fun <C> ListRationalFunction<C>.asFunctionOfPolynomialOver(ring: Ring<C>): (ListPolynomial<C>) -> ListRationalFunction<C>

Represent this rational function as a regular context-less function.

fun <C> NumberedPolynomial<C>.asFunctionOfPolynomialOver(ring: Ring<C>): (Buffer<NumberedPolynomial<C>>) -> NumberedPolynomial<C>

fun <C> NumberedRationalFunction<C>.asFunctionOfPolynomialOver(ring: Ring<C>): (Buffer<NumberedPolynomial<C>>) -> NumberedRationalFunction<C>

asFunctionOfRationalFunctionOver

fun <C> ListPolynomial<C>.asFunctionOfRationalFunctionOver(ring: Ring<C>): (ListRationalFunction<C>) -> ListRationalFunction<C>

Represent this polynomial as a regular context-less function.

fun <C> ListRationalFunction<C>.asFunctionOfRationalFunctionOver(ring: Ring<C>): (ListRationalFunction<C>) -> ListRationalFunction<C>

Represent this rational function as a regular context-less function.

fun <C> NumberedPolynomial<C>.asFunctionOfRationalFunctionOver(ring: Ring<C>): (Buffer<NumberedRationalFunction<C>>) -> NumberedRationalFunction<C>

fun <C> NumberedRationalFunction<C>.asFunctionOfRationalFunctionOver(ring: Ring<C>): (Buffer<NumberedRationalFunction<C>>) -> NumberedRationalFunction<C>

asFunctionOver

fun <C> ListPolynomial<C>.asFunctionOver(ring: Ring<C>): (C) -> C

Represent this polynomial as a regular context-less function.

fun <C> ListRationalFunction<C>.asFunctionOver(ring: Field<C>): (C) -> C

Represent this rational function as a regular context-less function.

fun <C> NumberedPolynomial<C>.asFunctionOver(ring: Ring<C>): (Buffer<C>) -> C

fun <C> NumberedRationalFunction<C>.asFunctionOver(ring: Field<C>): (Buffer<C>) -> C

asLabeledPolynomial

inline fun <C> C.asLabeledPolynomial(): LabeledPolynomial<C>

asListPolynomial

fun <C> C.asListPolynomial(): ListPolynomial<C>

Represents this constant as a ListPolynomial.

asListRationalFunction

fun <C> C.asListRationalFunction(ring: Ring<C>): ListRationalFunction<C>

Represents this constant as a rational function.

asNumberedPolynomial

inline fun <C> C.asNumberedPolynomial(): NumberedPolynomial<C>

derivative

@UnstableKoneAPI

fun <C, A : Ring<C>> ListPolynomial<C>.derivative(ring: A): ListPolynomial<C>

Returns algebraic derivative of received polynomial.

derivativeWithRespectTo

@ExperimentalKoneAPI

fun <C> LabeledPolynomial<C>.derivativeWithRespectTo(algebra: Ring<C>, variable: Symbol): LabeledPolynomial<C>

@ExperimentalKoneAPI

fun <C> NumberedPolynomial<C>.derivativeWithRespectTo(ring: Ring<C>, variable: Int): NumberedPolynomial<C>

integrate

@UnstableKoneAPI

fun <C : Comparable<C>> ListPolynomial<C>.integrate(ring: Field<C>, range: ClosedRange<C>): C

Computes a definite integral of this polynomial in the specified range.

LabeledPolynomial

fun <C> LabeledPolynomial(vararg pairs: Pair<LabeledMonomialSignature, C>, add: (C, C) -> C): LabeledPolynomial<C>

fun <C> LabeledPolynomial(pairs: Collection<Pair<LabeledMonomialSignature, C>>, add: (C, C) -> C): LabeledPolynomial<C>

fun <C> LabeledPolynomial(coefs: LabeledPolynomialCoefficients<C>, add: (C, C) -> C): LabeledPolynomial<C>

LabeledPolynomial

inline fun <C> Ring<C>.LabeledPolynomial(vararg pairs: Pair<LabeledMonomialSignature, C>): LabeledPolynomial<C>

inline fun <C> Ring<C>.LabeledPolynomial(pairs: Collection<Pair<LabeledMonomialSignature, C>>): LabeledPolynomial<C>

inline fun <C> Ring<C>.LabeledPolynomial(coefs: LabeledPolynomialCoefficients<C>): LabeledPolynomial<C>

inline fun <C> LabeledPolynomialSpace<C, *>.LabeledPolynomial(vararg pairs: Pair<LabeledMonomialSignature, C>): LabeledPolynomial<C>

inline fun <C> LabeledPolynomialSpace<C, *>.LabeledPolynomial(pairs: Collection<Pair<LabeledMonomialSignature, C>>): LabeledPolynomial<C>

inline fun <C> LabeledPolynomialSpace<C, *>.LabeledPolynomial(coefs: LabeledPolynomialCoefficients<C>): LabeledPolynomial<C>

inline fun <C> LabeledRationalFunctionSpace<C, *, *>.LabeledPolynomial(vararg pairs: Pair<LabeledMonomialSignature, C>): LabeledPolynomial<C>

inline fun <C> LabeledRationalFunctionSpace<C, *, *>.LabeledPolynomial(pairs: Collection<Pair<LabeledMonomialSignature, C>>): LabeledPolynomial<C>

inline fun <C> LabeledRationalFunctionSpace<C, *, *>.LabeledPolynomial(coefs: LabeledPolynomialCoefficients<C>): LabeledPolynomial<C>

LabeledPolynomialDSL1

@ExperimentalKoneAPI

inline fun <C> LabeledPolynomialSpace<C, *>.LabeledPolynomialDSL1(initialCapacity: Int? = null, block: DSL1LabeledPolynomialBuilder<C>.() -> Unit): LabeledPolynomial<C>

@ExperimentalKoneAPI

inline fun <C> LabeledRationalFunctionSpace<C, *, *>.LabeledPolynomialDSL1(initialCapacity: Int? = null, block: DSL1LabeledPolynomialBuilder<C>.() -> Unit): LabeledPolynomial<C>

LabeledPolynomialDSL2

@ExperimentalKoneAPI

fun <C> LabeledPolynomialSpace<C, Ring<C>>.LabeledPolynomialDSL2(initialCapacity: Int? = null, block: DSL2LabeledPolynomialBuilder<C>.() -> Unit): LabeledPolynomial<C>

@ExperimentalKoneAPI

fun <C> LabeledRationalFunctionSpace<C, Ring<C>, LabeledPolynomialSpace<C, Ring<C>>>.LabeledPolynomialDSL2(initialCapacity: Int? = null, block: DSL2LabeledPolynomialBuilder<C>.() -> Unit): LabeledPolynomial<C>

LabeledPolynomialWithoutCheck

inline fun <C> LabeledPolynomialWithoutCheck(vararg pairs: Pair<LabeledMonomialSignature, C>): LabeledPolynomial<C>

inline fun <C> LabeledPolynomialWithoutCheck(pairs: Collection<Pair<LabeledMonomialSignature, C>>): LabeledPolynomial<C>

inline fun <C> LabeledPolynomialWithoutCheck(coefs: LabeledPolynomialCoefficients<C>): LabeledPolynomial<C>

LabeledRationalFunction

fun <C> Ring<C>.LabeledRationalFunction(numerator: LabeledPolynomial<C>): LabeledRationalFunction<C>

fun <C> Ring<C>.LabeledRationalFunction(numeratorCoefficients: LabeledPolynomialCoefficients<C>): LabeledRationalFunction<C>

fun <C> LabeledRationalFunctionSpace<C, *, *>.LabeledRationalFunction(numerator: LabeledPolynomial<C>): LabeledRationalFunction<C>

fun <C> LabeledRationalFunctionSpace<C, *, *>.LabeledRationalFunction(numeratorCoefficients: LabeledPolynomialCoefficients<C>): LabeledRationalFunction<C>

fun <C> Ring<C>.LabeledRationalFunction(numeratorCoefficients: LabeledPolynomialCoefficients<C>, denominatorCoefficients: LabeledPolynomialCoefficients<C>): LabeledRationalFunction<C>

fun <C> LabeledRationalFunctionSpace<C, *, *>.LabeledRationalFunction(numeratorCoefficients: LabeledPolynomialCoefficients<C>, denominatorCoefficients: LabeledPolynomialCoefficients<C>): LabeledRationalFunction<C>

ListPolynomial

fun <C> ListPolynomial(vararg coefficients: C, reverse: Boolean = false): ListPolynomial<C>

fun <C> ListPolynomial(coefficients: List<C>, reverse: Boolean = false): ListPolynomial<C>

Constructs a ListPolynomial instance with provided coefficients. The collection of coefficients will be reversed if reverse parameter is true.

ListRationalFunction

fun <C> ListRationalFunction(numeratorCoefficients: List<C>, denominatorCoefficients: List<C>, reverse: Boolean = false): ListRationalFunction<C>

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.

ListRationalFunction

fun <C> Ring<C>.ListRationalFunction(numerator: ListPolynomial<C>): ListRationalFunction<C>

fun <C> ListRationalFunctionSpace<C, *, *>.ListRationalFunction(numerator: ListPolynomial<C>): ListRationalFunction<C>

Constructs ListRationalFunction instance with provided numerator and unit denominator.

fun <C> Ring<C>.ListRationalFunction(numeratorCoefficients: List<C>, reverse: Boolean = false): ListRationalFunction<C>

fun <C> ListRationalFunctionSpace<C, *, *>.ListRationalFunction(numeratorCoefficients: List<C>, reverse: Boolean = false): ListRationalFunction<C>

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.

nthAntiderivative

@UnstableKoneAPI

fun <C, A : Field<C>> ListPolynomial<C>.nthAntiderivative(ring: A, order: Int): ListPolynomial<C>

Returns algebraic antiderivative of received polynomial of specified order. The order should be non-negative integer.

nthAntiderivativeWithRespectTo

@ExperimentalKoneAPI

fun <C> LabeledPolynomial<C>.nthAntiderivativeWithRespectTo(algebra: Field<C>, variablesAndOrders: Map<Symbol, UInt>): LabeledPolynomial<C>

@ExperimentalKoneAPI

fun <C> NumberedPolynomial<C>.nthAntiderivativeWithRespectTo(ring: Field<C>, variablesAndOrders: Map<Int, UInt>): NumberedPolynomial<C>

@ExperimentalKoneAPI

fun <C> LabeledPolynomial<C>.nthAntiderivativeWithRespectTo(algebra: Field<C>, variable: Symbol, order: UInt): LabeledPolynomial<C>

@ExperimentalKoneAPI

fun <C> NumberedPolynomial<C>.nthAntiderivativeWithRespectTo(ring: Field<C>, variable: Int, order: UInt): NumberedPolynomial<C>

nthDerivative

@UnstableKoneAPI

fun <C, A : Ring<C>> ListPolynomial<C>.nthDerivative(ring: A, order: Int): ListPolynomial<C>

Returns algebraic derivative of received polynomial of specified order. The order should be non-negative integer.

nthDerivativeWithRespectTo

@ExperimentalKoneAPI

fun <C> LabeledPolynomial<C>.nthDerivativeWithRespectTo(algebra: Ring<C>, variablesAndOrders: Map<Symbol, UInt>): LabeledPolynomial<C>

@ExperimentalKoneAPI

fun <C> NumberedPolynomial<C>.nthDerivativeWithRespectTo(ring: Ring<C>, variablesAndOrders: Map<Int, UInt>): NumberedPolynomial<C>

@ExperimentalKoneAPI

fun <C> LabeledPolynomial<C>.nthDerivativeWithRespectTo(algebra: Ring<C>, variable: Symbol, order: UInt): LabeledPolynomial<C>

@ExperimentalKoneAPI

fun <C> NumberedPolynomial<C>.nthDerivativeWithRespectTo(ring: Ring<C>, variable: Int, order: UInt): NumberedPolynomial<C>

NumberedPolynomial

fun <C> NumberedPolynomial(vararg pairs: Pair<NumberedMonomialSignature, C>, add: (C, C) -> C): NumberedPolynomial<C>

fun <C> NumberedPolynomial(pairs: Collection<Pair<NumberedMonomialSignature, C>>, add: (C, C) -> C): NumberedPolynomial<C>

fun <C> NumberedPolynomial(coefs: NumberedPolynomialCoefficients<C>, add: (C, C) -> C): NumberedPolynomial<C>

NumberedPolynomial

inline fun <C> Ring<C>.NumberedPolynomial(vararg pairs: Pair<NumberedMonomialSignature, C>): NumberedPolynomial<C>

inline fun <C> Ring<C>.NumberedPolynomial(pairs: Collection<Pair<NumberedMonomialSignature, C>>): NumberedPolynomial<C>

inline fun <C> Ring<C>.NumberedPolynomial(coefs: NumberedPolynomialCoefficients<C>): NumberedPolynomial<C>

inline fun <C> NumberedPolynomialSpace<C, *>.NumberedPolynomial(vararg pairs: Pair<NumberedMonomialSignature, C>): NumberedPolynomial<C>

inline fun <C> NumberedPolynomialSpace<C, *>.NumberedPolynomial(pairs: Collection<Pair<NumberedMonomialSignature, C>>): NumberedPolynomial<C>

inline fun <C> NumberedPolynomialSpace<C, *>.NumberedPolynomial(coefs: NumberedPolynomialCoefficients<C>): NumberedPolynomial<C>

inline fun <C> NumberedRationalFunctionSpace<C, *, *>.NumberedPolynomial(vararg pairs: Pair<NumberedMonomialSignature, C>): NumberedPolynomial<C>

inline fun <C> NumberedRationalFunctionSpace<C, *, *>.NumberedPolynomial(pairs: Collection<Pair<NumberedMonomialSignature, C>>): NumberedPolynomial<C>

inline fun <C> NumberedRationalFunctionSpace<C, *, *>.NumberedPolynomial(coefs: NumberedPolynomialCoefficients<C>): NumberedPolynomial<C>

NumberedPolynomialDSL1

@ExperimentalKoneAPI

inline fun <C> NumberedPolynomialSpace<C, *>.NumberedPolynomialDSL1(initialCapacity: Int? = null, block: DSL1NumberedPolynomialBuilder<C>.() -> Unit): NumberedPolynomial<C>

@ExperimentalKoneAPI

inline fun <C> NumberedRationalFunctionSpace<C, *, *>.NumberedPolynomialDSL1(initialCapacity: Int? = null, block: DSL1NumberedPolynomialBuilder<C>.() -> Unit): NumberedPolynomial<C>

NumberedPolynomialWithoutCheck

inline fun <C> NumberedPolynomialWithoutCheck(vararg pairs: Pair<NumberedMonomialSignature, C>): NumberedPolynomial<C>

inline fun <C> NumberedPolynomialWithoutCheck(pairs: Collection<Pair<NumberedMonomialSignature, C>>): NumberedPolynomial<C>

inline fun <C> NumberedPolynomialWithoutCheck(coefs: NumberedPolynomialCoefficients<C>): NumberedPolynomial<C>

NumberedRationalFunction

fun <C> Ring<C>.NumberedRationalFunction(numerator: NumberedPolynomial<C>): NumberedRationalFunction<C>

fun <C> Ring<C>.NumberedRationalFunction(numeratorCoefficients: NumberedPolynomialCoefficients<C>): NumberedRationalFunction<C>

fun <C> NumberedRationalFunctionSpace<C, *, *>.NumberedRationalFunction(numerator: NumberedPolynomial<C>): NumberedRationalFunction<C>

fun <C> NumberedRationalFunctionSpace<C, *, *>.NumberedRationalFunction(numeratorCoefficients: NumberedPolynomialCoefficients<C>): NumberedRationalFunction<C>

fun <C> Ring<C>.NumberedRationalFunction(numeratorCoefficients: NumberedPolynomialCoefficients<C>, denominatorCoefficients: NumberedPolynomialCoefficients<C>): NumberedRationalFunction<C>

fun <C> NumberedRationalFunctionSpace<C, *, *>.NumberedRationalFunction(numeratorCoefficients: NumberedPolynomialCoefficients<C>, denominatorCoefficients: NumberedPolynomialCoefficients<C>): NumberedRationalFunction<C>

substitute

inline fun LabeledPolynomial<Double>.substitute(vararg inputs: Pair<Symbol, Double>): LabeledPolynomial<Double>

fun LabeledPolynomial<Double>.substitute(args: Map<Symbol, Double>): LabeledPolynomial<Double>

inline fun LabeledRationalFunction<Double>.substitute(vararg inputs: Pair<Symbol, Double>): LabeledRationalFunction<Double>

fun LabeledRationalFunction<Double>.substitute(args: Map<Symbol, Double>): LabeledRationalFunction<Double>

inline fun NumberedPolynomial<Double>.substitute(vararg inputs: Pair<Int, Double>): NumberedPolynomial<Double>

fun NumberedPolynomial<Double>.substitute(args: Map<Int, Double>): NumberedPolynomial<Double>

fun NumberedPolynomial<Double>.substitute(args: Buffer<Double>): NumberedPolynomial<Double>

inline fun NumberedRationalFunction<Double>.substitute(vararg inputs: Pair<Int, Double>): NumberedRationalFunction<Double>

fun NumberedRationalFunction<Double>.substitute(args: Map<Int, Double>): NumberedRationalFunction<Double>

fun NumberedRationalFunction<Double>.substitute(args: Buffer<Double>): NumberedRationalFunction<Double>

inline fun <C> LabeledPolynomial<C>.substitute(ring: Ring<C>, vararg inputs: Pair<Symbol, C>): LabeledPolynomial<C>

@JvmName(name = "substitutePolynomial")

inline fun <C> LabeledPolynomial<C>.substitute(ring: Ring<C>, vararg inputs: Pair<Symbol, LabeledPolynomial<C>>): LabeledPolynomial<C>