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

common

interface NumericAlgebra<T> : Algebra<T>

An algebraic structure where elements can have numeric representation.

PowerOperations

common

interface PowerOperations<T> : Algebra<T>

A context extension to include power operations based on exponentiation.

Ring

common

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

common

interface RingOps<T> : GroupOps<T>

Represents ring without multiplicative and additive identities i.e.

ScaleOperations

common

interface ScaleOperations<T> : Algebra<T>

Scale by scalar operations

ShortRing

common

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

A field for Short without boxing.

SuspendBufferTransform

common

typealias SuspendBufferTransform<T, R> = suspend (Buffer<T>) -> Buffer<R>

Typealias for buffer transformations with suspend function.

TrigonometricOperations

common

interface TrigonometricOperations<T> : Algebra<T>

A container for trigonometric operations for specific type.

WithSize

common

interface WithSize

Functions

abs

common

fun abs(x: BigInt): BigInt

Returns the absolute value of the given value x.

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

Absolute of the comparable value

acos

common

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

acosh

common

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

asin

common

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

asinh

common

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

asIterable

common

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

Creates an iterable that returns all elements from this Buffer.

asSequence

common

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

Creates a sequence that returns all elements from this Buffer.

atan

common

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

atanh

common

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

average

common

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

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

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

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

averageWith

common

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

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

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

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

bigInt

common

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

inline fun MutableBuffer.Companion.bigInt(size: Int, initializer: (Int) -> BigInt): MutableBuffer<BigInt>

bindSymbol

common

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

bindSymbolOrNull

common

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

buffer

common

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>

bufferAlgebra

common

fun <T, A : Field<T>> A.bufferAlgebra(bufferFactory: BufferFactory<T>): BufferFieldOps<T, A>

cos

common

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

cosh

common

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

exp

common

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

fold

common

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

Fold given buffer according to operation

invoke

common

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

Call a block with an Algebra as receiver.

common

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

map

common

inline fun <T : Any, R : Any> Buffer<T>.map(block: (T) -> R): Buffer<R>

Create a new buffer from this one with the given mapping function and using Buffer.Companion.auto buffer factory.

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

Create a new buffer from this one with the given mapping function.

mapIndexed

common

inline fun <T : Any, R : Any> Buffer<T>.mapIndexed(bufferFactory: BufferFactory<R> = Buffer.Companion::auto, crossinline block: (index: Int, T) -> R): Buffer<R>

Create a new buffer from this one with the given indexed mapping function.

mapIndexedInline

common

inline fun <T, A : Algebra<T>> BufferAlgebra<T, A>.mapIndexedInline(buffer: Buffer<T>, crossinline block: A.(index: Int, T) -> T): Buffer<T>

Inline map

mapInline

common

inline fun <T, A : Algebra<T>> BufferAlgebra<T, A>.mapInline(buffer: Buffer<T>, crossinline block: A.(T) -> T): Buffer<T>

Inline map

mutableBuffer

common

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

parseBigInteger

common

fun String.parseBigInteger(): BigInt?

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

pow

common

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

power

common

fun <T> Field<T>.power(arg: T, exponent: Int): T

Raises arg to the integer power exponent.

fun <T> Ring<T>.power(arg: T, exponent: UInt): T

Raises arg to the non-negative integer power exponent.

sin

common

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

sinh

common

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

sum

common

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

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

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

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

sumWith

common

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

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

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

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

tan

common

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

tanh

common

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

toBigInt

common

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

common

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

Returns a new List containing all elements of this buffer.

toMutableList

common

@UnstableKMathAPI()

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

Returns a new MutableList filled with all elements of this buffer.

toTypedArray

common

@UnstableKMathAPI()

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

Returns a new Array containing all elements of this buffer.

withSize

common

fun <T, A : Field<T>> BufferFieldOps<T, A>.withSize(size: Int): BufferField<T, A>

Generate full buffer field from given buffer operations

zip

common

@UnstableKMathAPI()

inline fun <T1 : Any, T2 : Any, R : Any> Buffer<T1>.zip(other: Buffer<T2>, bufferFactory: BufferFactory<R> = Buffer.Companion::auto, crossinline transform: (T1, T2) -> R): Buffer<R>

Zip two buffers using given transform.

zipInline

common