Represents field i.e., algebraic structure with three operations: associative, commutative addition and multiplication, and division. This interface differs from the eponymous mathematical definition: fields in KMath also support associative multiplication by scalar.

FieldOps

interface FieldOps<T> : RingOps<T>

Represents field without multiplicative and additive identities i.e., algebraic structure with associative, binary, commutative operations add and multiply; binary operation divide as multiplication of left operand by reciprocal of right one.

FloatField

object FloatField : ExtendedField<Float> , Norm<Float, Float>

A field for Float without boxing. Does not produce appropriate field element.

Group

interface Group<T> : GroupOps<T>

Represents group i.e., algebraic structure with associative, binary operation add.

GroupOps

interface GroupOps<T> : Algebra<T>

Represents group without neutral element (also known as inverse semigroup) i.e., algebraic structure with associative, binary operation add.

IntRing

object IntRing : Ring<Int> , Norm<Int, Int> , NumericAlgebra<Int>

A field for Int without boxing. Does not produce corresponding ring element.

JBigDecimalField

class JBigDecimalField(mathContext: MathContext = MathContext.DECIMAL64) : JBigDecimalFieldBase

A field over BigDecimal.

JBigDecimalFieldBase

abstract class JBigDecimalFieldBase : Field<BigDecimal> , PowerOperations<BigDecimal> , NumericAlgebra<BigDecimal> , ScaleOperations<BigDecimal>

An abstract field over BigDecimal.

JBigIntegerField

object JBigIntegerField : Ring<BigInteger> , NumericAlgebra<BigInteger>

A field over BigInteger.

LogicAlgebra

@UnstableKMathAPI

interface LogicAlgebra<T : Any> : Algebra<T>

An algebra for generic boolean logic

LongRing

object LongRing : Ring<Long> , Norm<Long, Long> , NumericAlgebra<Long>

A field for Double without boxing. Does not produce appropriate ring element.

Norm

interface Norm<in T : Any, out R>

A container for norm functional on element.

NumbersAddOps

@UnstableKMathAPI

interface NumbersAddOps<T> : RingOps<T> , NumericAlgebra<T>

A combination of NumericAlgebra and Ring that adds intrinsic simple operations on numbers like T+1 TODO to be removed and replaced by extensions after multiple receivers are there

NumericAlgebra

interface NumericAlgebra<T> : Algebra<T>

An algebraic structure where elements can have numeric representation.

PowerOperations

interface PowerOperations<T> : FieldOps<T>

A context extension to include power operations based on exponentiation.

Ring

interface Ring<T> : Group<T> , RingOps<T>

Represents ring i.e., algebraic structure with two associative binary operations called "addition" and "multiplication" and their neutral elements.

RingOps

interface RingOps<T> : GroupOps<T>

Represents ring without multiplicative and additive identities i.e., algebraic structure with associative, binary, commutative operation add and associative, operation multiply distributive over add.

ScaleOperations

interface ScaleOperations<T> : Algebra<T>

Scale by scalar operations

ShortRing

object ShortRing : Ring<Short> , Norm<Short, Short> , NumericAlgebra<Short>

A field for Short without boxing. Does not produce appropriate ring element.

TrigonometricOperations

interface TrigonometricOperations<T> : Algebra<T>

A container for trigonometric operations for specific type.

WithSize

interface WithSize

Functions

abs

fun abs(x: BigInt): BigInt

Returns the absolute value of the given value x.

abs

fun <T : Comparable<T>> Group<T>.abs(value: T): T

Absolute of the comparable value

acos

fun <T, A : TrigonometricOperations<T>> BufferAlgebra<T, A>.acos(arg: Buffer<T>): Buffer<T>

acosh

fun <T, A : ExponentialOperations<T>> BufferAlgebra<T, A>.acosh(arg: Buffer<T>): Buffer<T>

asin

fun <T, A : TrigonometricOperations<T>> BufferAlgebra<T, A>.asin(arg: Buffer<T>): Buffer<T>

asinh

fun <T, A : ExponentialOperations<T>> BufferAlgebra<T, A>.asinh(arg: Buffer<T>): Buffer<T>

asIterable

fun <T> Buffer<T>.asIterable(): Iterable<T>

Creates an iterable that returns all elements from this Buffer.

asSequence

fun <T> Buffer<T>.asSequence(): Sequence<T>

Creates a sequence that returns all elements from this Buffer.

atan

fun <T, A : TrigonometricOperations<T>> BufferAlgebra<T, A>.atan(arg: Buffer<T>): Buffer<T>

atanh

fun <T, A : ExponentialOperations<T>> BufferAlgebra<T, A>.atanh(arg: Buffer<T>): Buffer<T>

average

fun <T, S : Group<T>, ScaleOperations<T>> S.average(data: Iterable<T>): T

@PerformancePitfall(message = "Potential boxing access to buffer elements")

fun <T, S : Group<T>, ScaleOperations<T>> S.average(data: Buffer<T>): T

Returns an average value of elements in the iterable in this Group.

fun <T, S : Group<T>, ScaleOperations<T>> S.average(data: Sequence<T>): T

Returns an average value of elements in the sequence in this Group.

fun DoubleBufferOps.average(buffer: Buffer<Double>): Double

averageOf

inline fun <T> DoubleBufferOps.averageOf(buffer: Buffer<T>, conversion: (T) -> Double): Double

Average of elements using given conversion

averageWith

fun <T, S : Group<T>, ScaleOperations<T>> Iterable<T>.averageWith(space: S): T

Returns an average value of elements in the iterable in this Group.

fun <T, S : Group<T>, ScaleOperations<T>> Sequence<T>.averageWith(space: S): T

Returns an average value of elements in the sequence in this Group.

bindSymbol

fun <T> Algebra<T>.bindSymbol(symbol: Symbol): T

bindSymbolOrNull

fun <T> Algebra<T>.bindSymbolOrNull(symbol: Symbol): T?

buffer

fun <T, A : BufferAlgebra<T, *>, WithSize> A.buffer(initializer: (Int) -> T): Buffer<T>

fun BufferField<Double, *>.buffer(vararg elements: Number): Buffer<Double>

inline fun BigInt.Companion.buffer(size: Int, initializer: (Int) -> BigInt): Buffer<BigInt>

fun <T> BufferAlgebra<T, *>.buffer(size: Int, initializer: (Int) -> T): Buffer<T>

combineToBuffer

@UnstableKMathAPI

inline fun <T1, T2, R> Buffer<T1>.combineToBuffer(other: Buffer<T2>, bufferFactory: BufferFactory<R>, crossinline transform: (T1, T2) -> R): Buffer<R>

Zip two buffers using given transform.

cos

fun <T, A : TrigonometricOperations<T>> BufferAlgebra<T, A>.cos(arg: Buffer<T>): Buffer<T>

cosh

fun <T, A : ExponentialOperations<T>> BufferAlgebra<T, A>.cosh(arg: Buffer<T>): Buffer<T>

covariance

fun DoubleBufferOps.covariance(x: Buffer<Double>, y: Buffer<Double>): Double

dispersion

fun DoubleBufferOps.dispersion(buffer: Buffer<Double>): Double

exp

fun <T, A : ExponentialOperations<T>> BufferAlgebra<T, A>.exp(arg: Buffer<T>): Buffer<T>

fold

inline fun <T, R> Buffer<T>.fold(initial: R, operation: (acc: R, T) -> R): R

Fold given buffer according to operation

foldIndexed

inline fun <T : Any, R> Buffer<T>.foldIndexed(initial: R, operation: (index: Int, acc: R, T) -> R): R

Fold given buffer according to indexed operation

invoke

inline operator fun <A : Algebra<*>, R> A.invoke(block: A.() -> R): R

Call a block with an Algebra as receiver.

isInteger

expect fun Number.isInteger(): Boolean

Check if number is an integer from platform point of view

actual fun Number.isInteger(): Boolean

Check if number is an integer

actual fun Number.isInteger(): Boolean

Check if number is an integer

actual fun Number.isInteger(): Boolean

Check if number is an integer

actual fun Number.isInteger(): Boolean

Check if number is an integer from platform point of view

fun <T, A : ExponentialOperations<T>> BufferAlgebra<T, A>.ln(arg: Buffer<T>): Buffer<T>

mapIndexedToBuffer

inline fun <T, R> Buffer<T>.mapIndexedToBuffer(bufferFactory: BufferFactory<R>, crossinline block: (index: Int, value: T) -> R): Buffer<R>

Create a new buffer from this one with the given mapping (indexed) function. Provided bufferFactory is used to construct the new buffer.

mapToBuffer

inline fun <T, R> Buffer<T>.mapToBuffer(bufferFactory: BufferFactory<R>, crossinline block: (T) -> R): Buffer<R>

Create a new buffer from this one with the given mapping function. Provided bufferFactory is used to construct the new buffer.

mutableBuffer

inline fun BigInt.Companion.mutableBuffer(size: Int, initializer: (Int) -> BigInt): Buffer<BigInt>

parseBigInteger

fun String.parseBigInteger(): BigInt?

Returns null if a valid number cannot be read from a string

pow

fun <T, A : PowerOperations<T>> BufferAlgebra<T, A>.pow(arg: Buffer<T>, pow: Number): Buffer<T>

reduce

inline fun <T> Buffer<T>.reduce(operation: (left: T, value: T) -> T): T

Reduce a buffer from left to right according to operation

sin

fun <T, A : TrigonometricOperations<T>> BufferAlgebra<T, A>.sin(arg: Buffer<T>): Buffer<T>

sinh

fun <T, A : ExponentialOperations<T>> BufferAlgebra<T, A>.sinh(arg: Buffer<T>): Buffer<T>

std

fun DoubleBufferOps.std(buffer: Buffer<Double>): Double

sum

fun DoubleBufferOps.sum(buffer: Buffer<Double>): Double

fun <T> Group<T>.sum(data: Iterable<T>): T

@PerformancePitfall(message = "Potential boxing access to buffer elements")

fun <T> Group<T>.sum(data: Buffer<T>): T

Returns the sum of all elements in the iterable in this Group.

fun <T> Group<T>.sum(data: Sequence<T>): T

Returns the sum of all elements in the sequence in this Group.

sumOf

inline fun <T> DoubleBufferOps.sumOf(buffer: Buffer<T>, conversion: (T) -> Double): Double

Sum of elements using given conversion

sumWith

fun <T> Iterable<T>.sumWith(group: Group<T>): T

Returns the sum of all elements in the iterable in provided space.

fun <T> Sequence<T>.sumWith(group: Group<T>): T

Returns the sum of all elements in the sequence in provided space.

sumWithGroupOf

inline fun <T, R> Iterable<T>.sumWithGroupOf(group: Group<R>, extractor: (T) -> R): R

Sum extracted elements of Iterable with given group

tan

fun <T, A : TrigonometricOperations<T>> BufferAlgebra<T, A>.tan(arg: Buffer<T>): Buffer<T>

tanh

fun <T, A : ExponentialOperations<T>> BufferAlgebra<T, A>.tanh(arg: Buffer<T>): Buffer<T>

toBigInt

fun Int.toBigInt(): BigInt

Convert this Int to BigInt

fun Long.toBigInt(): BigInt

Convert this Long to BigInt

fun UInt.toBigInt(): BigInt

Convert UInt to BigInt

fun ULong.toBigInt(): BigInt

Convert ULong to BigInt

fun UIntArray.toBigInt(sign: Byte): BigInt

Create a BigInt with this array of magnitudes with protective copy

toList

fun <T> Buffer<T>.toList(): List<T>

Returns a new List containing all elements of this buffer.

toMutableList

@UnstableKMathAPI

fun <T> Buffer<T>.toMutableList(): MutableList<T>

Returns a new MutableList filled with all elements of this buffer. NOTE: this method uses a protective copy, so it should not be used in performance-critical code.

toTypedArray

@UnstableKMathAPI

inline fun <T> Buffer<T>.toTypedArray(): Array<T>

Returns a new Array containing all elements of this buffer. NOTE: this method uses a protective copy, so it should not be used in performance-critical code.

withSize