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>

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>

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

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.