An interface representing a type that can be converted into a Vector4. This allows classes implementing this interface to define a custom transformation or mapping to a Vector4 instance, enabling compatibility with systems and operations that utilize 4-dimensional vectors.

EuclideanVector

interface EuclideanVector<T : EuclideanVector<T>, LinearType<T>> : LinearType<T>

GeometricPrimitive2D

interface GeometricPrimitive2D

Represents a basic geometric primitive in a 2D space.

GeometricPrimitive3D

interface GeometricPrimitive3D

Represents a basic geometric primitive in a 3D space.

Hashes

object Hashes

From ztellman's Artifex library

IntVector2

@Serializable

@JvmRecord

data class IntVector2(val x: Int, val y: Int)

Integer 2D vector, exclusively for integer calculations.

IntVector3

@Serializable

@JvmRecord

data class IntVector3(val x: Int, val y: Int, val z: Int)

Integer 3D vector, exclusively for integer calculations.

IntVector4

@Serializable

@JvmRecord

data class IntVector4(val x: Int, val y: Int, val z: Int, val w: Int)

Integer 4D vector, exclusively for integer calculations.

LinearType

interface LinearType<T : LinearType<T>>

Represents a linear type that supports basic arithmetic operations for objects of the same type. This interface enforces a linear structure that can be used to define custom mathematical types.

Matrix33

@Serializable

@JvmRecord

data class Matrix33(val c0r0: Double = 0.0, val c1r0: Double = 0.0, val c2r0: Double = 0.0, val c0r1: Double = 0.0, val c1r1: Double = 0.0, val c2r1: Double = 0.0, val c0r2: Double = 0.0, val c1r2: Double = 0.0, val c2r2: Double = 0.0) : LinearType<Matrix33>

A 3x3 matrix with double precision

Matrix44

@Serializable

@JvmRecord

data class Matrix44(val c0r0: Double = 0.0, val c1r0: Double = 0.0, val c2r0: Double = 0.0, val c3r0: Double = 0.0, val c0r1: Double = 0.0, val c1r1: Double = 0.0, val c2r1: Double = 0.0, val c3r1: Double = 0.0, val c0r2: Double = 0.0, val c1r2: Double = 0.0, val c2r2: Double = 0.0, val c3r2: Double = 0.0, val c0r3: Double = 0.0, val c1r3: Double = 0.0, val c2r3: Double = 0.0, val c3r3: Double = 0.0) : LinearType<Matrix44>

A 4x4 matrix with double precision

Matrix55

@Serializable

@JvmRecord

data class Matrix55(val c0r0: Double = 0.0, val c1r0: Double = 0.0, val c2r0: Double = 0.0, val c3r0: Double = 0.0, val c4r0: Double = 0.0, val c0r1: Double = 0.0, val c1r1: Double = 0.0, val c2r1: Double = 0.0, val c3r1: Double = 0.0, val c4r1: Double = 0.0, val c0r2: Double = 0.0, val c1r2: Double = 0.0, val c2r2: Double = 0.0, val c3r2: Double = 0.0, val c4r2: Double = 0.0, val c0r3: Double = 0.0, val c1r3: Double = 0.0, val c2r3: Double = 0.0, val c3r3: Double = 0.0, val c4r3: Double = 0.0, val c0r4: Double = 0.0, val c1r4: Double = 0.0, val c2r4: Double = 0.0, val c3r4: Double = 0.0, val c4r4: Double = 0.0)

A 5x5 matrix with double precision

Parametric1D

interface Parametric1D<R>

Represents a 1-dimensional parametric function that computes a value of type R based on a parameter t of type Double. This interface can be implemented to define various parametric mathematical or functional relationships.

Parametric2D

interface Parametric2D<R>

Parametric2D defines a two-dimensional parametric function.

Parametric3D

interface Parametric3D<R>

Represents a three-dimensional parametric function.

Parametric4D

interface Parametric4D<R>

Represents a parametrized function defined in a 4D space. Provides the means to compute a value of type R given four input parameters: u, v, w, and t, typically representing dimensions or coordinates in the 4D space.

Polar

@Serializable

@JvmRecord

data class Polar(val theta: Double, val radius: Double = 1.0) : LinearType<Polar>

A 2D point defined in the Polar coordinate system.

Quaternion

@Serializable

@JvmRecord

data class Quaternion(val x: Double, val y: Double, val z: Double, val w: Double)

Quaternion class for representing orientations in 3D space

Spherical

@Serializable

@JvmRecord

data class Spherical(val theta: Double, val phi: Double, val radius: Double) : LinearType<Spherical>

Spherical coordinate. The poles (phi) are at the positive and negative y-axis. The equator starts at positive z.

Vector1

@JvmInline

value class Vector1(val x: Double) : EuclideanVector<Vector1>

Vector2

@Serializable

@JvmRecord

data class Vector2(val x: Double, val y: Double) : LinearType<Vector2> , EuclideanVector<Vector2> , GeometricPrimitive2D

A 2D vector representation in Cartesian coordinates with methods for mathematical operations and conversions. Implements linear algebra functionalities and provides utility methods for creating and manipulating 2D vectors.

Vector3

@Serializable

@JvmRecord

data class Vector3(val x: Double, val y: Double, val z: Double) : LinearType<Vector3> , EuclideanVector<Vector3>

Double-precision 3D vector.

Vector4

@Serializable

@JvmRecord

data class Vector4(val x: Double, val y: Double, val z: Double, val w: Double) : LinearType<Vector4> , EuclideanVector<Vector4>

Double-precision 4D vector.

YPolarity

enum YPolarity : Enum<YPolarity>

YPolarity defines the orientation of the Y-axis in a coordinate system.

Properties

asDegrees

val Double.asDegrees: Double

asExponent

val Double.asExponent: Int

asRadians

val Double.asRadians: Double

Functions

average

fun Iterable<Vector2>.average(): Vector2

Computes the average of all Vector2 instances in the iterable.

fun Iterable<Vector3>.average(): Vector3

fun Iterable<Vector4>.average(): Vector4

Calculates the component-wise average of all Vector4 elements in the iterable.

bezier

fun <T : LinearType<T>> bezier(x0: T, c0: T, x1: T, t: Double): T

fun bezier(x0: Double, c0: Double, x1: Double, t: Double): Double

fun <T : LinearType<T>> bezier(x0: T, c0: T, c1: T, x1: T, t: Double): T

fun bezier(x0: Vector2, c0: Vector2, x1: Vector2, t: Double): Vector2

Evaluate a 2D quadratic bezier defined by (x0, c0, x1) for t

fun bezier(x0: Vector3, c0: Vector3, x1: Vector3, t: Double): Vector3

Evaluate a 3D quadratic bezier defined by (x0, c0, x1) for t

fun bezier(x0: Double, c0: Double, c1: Double, x1: Double, t: Double): Double

Evaluate a cubic bezier defined by (x0, c0, c1, x1) for t

fun bezier(x0: Vector2, c0: Vector2, c1: Vector2, x1: Vector2, t: Double): Vector2

Evaluate a 2D cubic bezier defined by (x0, c0, c1, x1) for t

fun bezier(x0: Vector3, c0: Vector3, c1: Vector3, x1: Vector3, t: Double): Vector3

Samples a single point based on the provided t value from given 3D cubic Bézier curve.

clamp

fun clamp(value: Double, min: Double, max: Double): Double

fun clamp(value: Int, min: Int, max: Int): Int

Returns number whose value is limited between min and max.

clamp

@JvmName(name = "doubleClamp")

fun Double.clamp(min: Double, max: Double): Double

@JvmName(name = "intClamp")

fun Int.clamp(min: Int, max: Int): Int

fun IntVector2.clamp(min: IntVector2, max: IntVector2): IntVector2

Returns IntVector2 whose value is limited between min and max per vector component.

fun IntVector3.clamp(min: IntVector3, max: IntVector3): IntVector3

Returns IntVector3 whose value is limited between min and max per vector component.

fun IntVector4.clamp(min: IntVector4, max: IntVector4): IntVector4

Returns IntVector4 whose value is limited between min and max per vector component.

fun Vector2.clamp(min: Vector2, max: Vector2): Vector2

Returns Vector2 whose value is limited between min and max per vector component.

fun Vector3.clamp(min: Vector3, max: Vector3): Vector3

Returns Vector3 whose value is limited between min and max per vector component.

fun Vector4.clamp(min: Vector4, max: Vector4): Vector4

Returns Vector4 whose value is limited between min and max per vector component.

derivative

fun derivative(x0: Double, c0: Double, x1: Double, t: Double): Double

fun derivative(x0: Vector2, c0: Vector2, x1: Vector2, t: Double): Vector2

fun derivative(x0: Vector3, c0: Vector3, x1: Vector3, t: Double): Vector3

fun derivative(p0: Double, p1: Double, p2: Double, p3: Double, t: Double): Double

fun derivative(p0: Vector2, p1: Vector2, p2: Vector2, p3: Vector2, t: Double): Vector2

fun derivative(p0: Vector3, p1: Vector3, p2: Vector3, p3: Vector3, t: Double): Vector3

derivative2

fun derivative2(p0: Double, p1: Double, p2: Double, p3: Double, t: Double): Double

fun derivative2(p0: Vector2, p1: Vector2, p2: Vector2, p3: Vector2, t: Double): Vector2

fun derivative2(p0: Vector3, p1: Vector3, p2: Vector3, p3: Vector3, t: Double): Vector3

dot

fun dot(q1: Quaternion, q2: Quaternion): Double

fma

expect inline fun fma(a: Double, b: Double, c: Double): Double

Performs a fused multiply-add operation, which computes (a * b) + c with only one rounding step. This provides better precision compared to performing the operations separately.

actual inline fun fma(a: Double, b: Double, c: Double): Double

fmaDot

inline fun fmaDot(a0: Double, b0: Double, a1: Double, b1: Double): Double

Computes a fused multiply-add operation and sums the results of two multiplications. Specifically, it calculates (a1 * b1 + a0 * b0) in a way that ensures higher precision.

inline fun fmaDot(a0: Double, b0: Double, a1: Double, b1: Double, a2: Double, b2: Double): Double

Computes the dot product of two 3-dimensional vectors using fused multiply-add operations to enhance precision. The vectors are represented as pairs of coordinates, where the first vector's components are (a0, a1, a2) and the second vector's components are (b0, b1, b2).

inline fun fmaDot(a0: Double, b0: Double, a1: Double, b1: Double, a2: Double, b2: Double, a3: Double, b3: Double): Double

Computes the dot product of two 4-dimensional vectors using fused multiply-add operations for enhanced precision. The result is calculated as: (a0 * b0) + (a1 * b1) + (a2 * b2) + (a3 * b3) using fused operations.

fmaDot3

inline fun fmaDot3(a0: Double, b0: Double, c0: Double, a1: Double, b1: Double, c1: Double, a2: Double, b2: Double, c2: Double, a3: Double, b3: Double, c3: Double, a4: Double, b4: Double, c4: Double, a5: Double, b5: Double, c5: Double): Double

Computes the dot product of three 3-dimensional vectors, combined with fused-multiply-add (FMA) operations for increased precision by avoiding intermediate rounding errors.

fmaDot4

inline fun fmaDot4(a0: Double, b0: Double, c0: Double, d0: Double, a1: Double, b1: Double, c1: Double, d1: Double, a2: Double, b2: Double, c2: Double, d2: Double, a3: Double, b3: Double, c3: Double, d3: Double): Double

Computes a fused multiply-add dot product operation across four sets of inputs. Each set performs multiplications, computes fused additions, and sums them into a single result, ensuring improved precision through the usage of fused multiply-add operations.

fmaDotC

inline fun fmaDotC(a0: Double, b0: Double, a1: Double, b1: Double, c: Double): Double

Computes a fused multiply-add operation for two pairs of values and a constant offset. This function calculates a0 * b0 + c, then uses the result as the offset for a1 * b1. The fma operation ensures higher precision by performing the operations in a single rounding step.

inline fun fmaDotC(a0: Double, b0: Double, a1: Double, b1: Double, a2: Double, b2: Double, c: Double): Double

Computes the dot product of three vector components combined with an additional constant term, using fused multiply-add operations for improved precision.

inline fun fmaDotC(a0: Double, b0: Double, a1: Double, b1: Double, a2: Double, b2: Double, a3: Double, b3: Double, c: Double): Double

Computes the dot product of four (a, b) pairs with an additional constant value c. This operation is performed using fused multiply-add operations for improved precision.

linearstep

fun linearstep(edge0: Double, edge1: Double, x: Double): Double

map

fun map(before: ClosedFloatingPointRange<Double>, after: ClosedFloatingPointRange<Double>, value: Double, clamp: Boolean = false): Double

fun map(beforeLeft: Double, beforeRight: Double, afterLeft: Double, afterRight: Double, value: Double, clamp: Boolean = false): Double

Linearly maps a value, which is given in the before domain to a value in the after domain.

map

fun Double.map(before: ClosedFloatingPointRange<Double>, after: ClosedFloatingPointRange<Double>, clamp: Boolean = false): Double

Linearly maps a value, which is given in the before domain to a value in the after domain.

@JvmName(name = "doubleMap")

fun Double.map(beforeLeft: Double, beforeRight: Double, afterLeft: Double, afterRight: Double, clamp: Boolean = false): Double

Linearly maps a value, which is given in the before domain to a value in the after domain

fun Vector2.map(beforeLeft: Vector2, beforeRight: Vector2, afterLeft: Vector2, afterRight: Vector2, clamp: Boolean = false): Vector2

fun Vector3.map(beforeLeft: Vector3, beforeRight: Vector3, afterLeft: Vector3, afterRight: Vector3, clamp: Boolean = false): Vector3

fun Vector4.map(beforeLeft: Vector4, beforeRight: Vector4, afterLeft: Vector4, afterRight: Vector4, clamp: Boolean = false): Vector4

max

fun max(a: Vector2, b: Vector2): Vector2

Determines the component-wise maximum of two 2D vectors.

fun max(a: Vector3, b: Vector3): Vector3

fun max(a: Vector4, b: Vector4): Vector4

min

fun min(a: Vector2, b: Vector2): Vector2

Computes the component-wise minimum of two 2D vectors.

fun min(a: Vector3, b: Vector3): Vector3

fun min(a: Vector4, b: Vector4): Vector4

mix

fun mix(left: Double, right: Double, x: Double): Double

fun mix(a: Vector2, b: Vector2, mix: Double): Vector2

fun mix(a: Vector3, b: Vector3, mix: Double): Vector3

fun mix(a: Vector4, b: Vector4, mix: Double): Vector4

mixAngle

fun mixAngle(leftAngle: Double, rightAngle: Double, x: Double): Double

Similar to mix() but assuming that 355° and 5° are 10° apart, not 350°.

mod

fun IntVector2.mod(b: IntVector2): IntVector2

fun IntVector3.mod(b: IntVector3): IntVector3

fun IntVector4.mod(b: IntVector4): IntVector4

fun Vector2.mod(b: Vector2): Vector2

fun Vector3.mod(b: Vector3): Vector3

fun Vector4.mod(b: Vector4): Vector4

normal

fun normal(x0: Vector2, c0: Vector2, x1: Vector2, t: Double): Vector2

normalizationFactor

fun normalizationFactor(a: Double, b: Double): Double

fun normalizationFactor(a: Double, b: Double, c: Double): Double

Computes a normalization factor based on the input values a, b, and c. The factor is calculated as a power of 2, inversely proportional to the largest exponent of the input values, if it falls outside the range of -8, 8. Otherwise, the factor defaults to 1.0.