0.0.0-experiment-2025.3.27

kone.computationalGeometry/dev.lounres.kone.computationalGeometry

Package-level declarations

Types

DelicatePolytopicConstructionAPI

@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 DelicatePolytopicConstructionAPI

Marks declarations that give access to internal entities of polytopic constructions 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.

EuclideanKategory

interface EuclideanKategory<N>

EuclideanKategory2

interface EuclideanKategory2<N>

EuclideanKategory2Scope

data class EuclideanKategory2Scope<N, A : Ring<N>, E : EuclideanKategory2<N>>(val numberRing: A, val numberOrder: Order<N>, val euclideanKategory: E)

EuclideanKategory3

interface EuclideanKategory3<N>

EuclideanKategory3Scope

data class EuclideanKategory3Scope<N, A : Ring<N>, E : EuclideanKategory3<N>>(val numberRing: A, val numberOrder: Order<N>, val euclideanKategory: E)

EuclideanKategory4

interface EuclideanKategory4<N>

EuclideanKategory4Scope

data class EuclideanKategory4Scope<N, A : Ring<N>, E : EuclideanKategory4<N>>(val numberRing: A, val numberOrder: Order<N>, val euclideanKategory: E)

@Serializable(with = PointSerializer::class)

open class Point<out N>(val coordinates: ColumnVector<N>)

@Serializable(with = Point2Serializer::class)

class Point2<out N>(coordinates: ColumnVector<N>) : Point<N>

@Serializable(with = Point3Serializer::class)

class Point3<out N>(coordinates: ColumnVector<N>) : Point<N>

@Serializable(with = Point4Serializer::class)

class Point4<out N>(coordinates: ColumnVector<N>) : Point<N>

@Serializable(with = VectorSerializer::class)

open class Vector<out N>(val coordinates: ColumnVector<N>)

@Serializable(with = Vector2Serializer::class)

class Vector2<out N>(coordinates: ColumnVector<N>) : Vector<N>

@Serializable(with = Vector3Serializer::class)

class Vector3<out N>(coordinates: ColumnVector<N>) : Vector<N>

@Serializable(with = Vector4Serializer::class)

class Vector4<out N>(coordinates: ColumnVector<N>) : Vector<N>

Properties

val <N> Vector2<N>.lengthSquared: N

val <N> Vector3<N>.lengthSquared: N

val <N> Vector4<N>.lengthSquared: N

val <N> Vector<N>.lengthSquared: N

Functions

infix fun <N> Vector2<N>.dot(other: Vector2<N>): N

infix fun <N> Vector3<N>.dot(other: Vector3<N>): N

infix fun <N> Vector4<N>.dot(other: Vector4<N>): N

infix fun <N> Vector<N>.dot(other: Vector<N>): N

euclideanKategory

fun <N> Ring<N>.euclideanKategory(vectorKategory: VectorKategory<N> = vectorKategory()): EuclideanKategory<N>

euclideanKategory2

fun <N> Ring<N>.euclideanKategory2(vectorKategory: VectorKategory<N> = vectorKategory()): EuclideanKategory2<N>

euclideanKategory3

fun <N> Ring<N>.euclideanKategory3(vectorKategory: VectorKategory<N> = vectorKategory()): EuclideanKategory3<N>

euclideanKategory4

fun <N> Ring<N>.euclideanKategory4(vectorKategory: VectorKategory<N> = vectorKategory()): EuclideanKategory4<N>

inEuclideanKategory2For

inline fun <N, R> KoneContextRegistry.inEuclideanKategory2For(numberType: SuppliedType<N>, block: (EuclideanKategory2<N>) -> R): R

inEuclideanKategory3For

inline fun <N, R> KoneContextRegistry.inEuclideanKategory3For(numberType: SuppliedType<N>, block: (EuclideanKategory3<N>) -> R): R

inEuclideanKategory4For

inline fun <N, R> KoneContextRegistry.inEuclideanKategory4For(numberType: SuppliedType<N>, block: (EuclideanKategory4<N>) -> R): R

inEuclideanKategoryFor

fun <N, R> KoneContextRegistry.inEuclideanKategoryFor(numberType: SuppliedType<N>, block: (EuclideanKategory<N>) -> R): R

inEuclideanKategoryScope2For

inline fun <N, R> KoneContextRegistry.inEuclideanKategoryScope2For(numberType: SuppliedType<N>, block: (Ring<N>, Order<N>, EuclideanKategory2<N>) -> R): R

inEuclideanKategoryScope3For

inline fun <N, R> KoneContextRegistry.inEuclideanKategoryScope3For(numberType: SuppliedType<N>, block: (Ring<N>, Order<N>, EuclideanKategory3<N>) -> R): R

inEuclideanKategoryScope4For

inline fun <N, R> KoneContextRegistry.inEuclideanKategoryScope4For(numberType: SuppliedType<N>, block: (Ring<N>, Order<N>, EuclideanKategory4<N>) -> R): R

inEuclideanKategoryScopeFor

fun <N, R> KoneContextRegistry.inEuclideanKategoryScopeFor(numberType: SuppliedType<N>, block: (Ring<N>, Order<N>, EuclideanKategory<N>) -> R): R

installEuclideanKategory2For

fun <N> KoneContextRegistryBuilder.installEuclideanKategory2For(numberType: SuppliedType<N>)

installEuclideanKategory3For

fun <N> KoneContextRegistryBuilder.installEuclideanKategory3For(numberType: SuppliedType<N>)

installEuclideanKategory4For

fun <N> KoneContextRegistryBuilder.installEuclideanKategory4For(numberType: SuppliedType<N>)

installEuclideanKategoryFor

fun <N> KoneContextRegistryBuilder.installEuclideanKategoryFor(numberType: SuppliedType<N>)

inline operator fun <N, A : Ring<N>, E : EuclideanKategory2<N>, R> EuclideanKategory2Scope<N, A, E>.invoke(block: (A, E) -> R): R

inline operator fun <N, A : Ring<N>, E : EuclideanKategory3<N>, R> EuclideanKategory3Scope<N, A, E>.invoke(block: (A, E) -> R): R

inline operator fun <N, A : Ring<N>, E : EuclideanKategory4<N>, R> EuclideanKategory4Scope<N, A, E>.invoke(block: (A, E) -> R): R

operator fun <N> Point2<N>.minus(other: Point2<N>): Vector2<N>

operator fun <N> Point2<N>.minus(other: Vector2<N>): Point2<N>

operator fun <N> Point3<N>.minus(other: Point3<N>): Vector3<N>

operator fun <N> Point3<N>.minus(other: Vector3<N>): Point3<N>

operator fun <N> Point4<N>.minus(other: Point4<N>): Vector4<N>

operator fun <N> Point4<N>.minus(other: Vector4<N>): Point4<N>

operator fun <N> Point<N>.minus(other: Point<N>): Vector<N>

operator fun <N> Point<N>.minus(other: Vector<N>): Point<N>

operator fun <N> Vector2<N>.minus(other: Vector2<N>): Vector2<N>

operator fun <N> Vector3<N>.minus(other: Vector3<N>): Vector3<N>

operator fun <N> Vector4<N>.minus(other: Vector4<N>): Vector4<N>

operator fun <N> Vector<N>.minus(other: Vector<N>): Vector<N>

operator fun <N> Point2<N>.plus(other: Vector2<N>): Point2<N>

operator fun <N> Point3<N>.plus(other: Vector3<N>): Point3<N>

operator fun <N> Point4<N>.plus(other: Vector4<N>): Point4<N>

operator fun <N> Point<N>.plus(other: Vector<N>): Point<N>

operator fun <N> Vector2<N>.plus(other: Point2<N>): Point2<N>

operator fun <N> Vector2<N>.plus(other: Vector2<N>): Vector2<N>

operator fun <N> Vector3<N>.plus(other: Point3<N>): Point3<N>

operator fun <N> Vector3<N>.plus(other: Vector3<N>): Vector3<N>

operator fun <N> Vector4<N>.plus(other: Point4<N>): Point4<N>

operator fun <N> Vector4<N>.plus(other: Vector4<N>): Vector4<N>

operator fun <N> Vector<N>.plus(other: Point<N>): Point<N>

operator fun <N> Vector<N>.plus(other: Vector<N>): Vector<N>

fun <N> Point(coordinates: MDList1<N>): Point<N>

fun <N> Point(vararg coordinates: N): Point<N>

fun <N> Point(size: UInt, initializer: (coordinate: UInt) -> N): Point<N>

fun <N> Point2(coordinates: MDList1<N>): Point2<N>

fun <N> Point2(x: N, y: N): Point2<N>

fun <N> Point3(coordinates: MDList1<N>): Point3<N>

fun <N> Point3(x: N, y: N): Point3<N>

fun <N> Point4(coordinates: MDList1<N>): Point4<N>

fun <N> Point4(x: N, y: N): Point4<N>

operator fun <N> N.times(other: Vector2<N>): Vector2<N>

operator fun <N> N.times(other: Vector3<N>): Vector3<N>

operator fun <N> N.times(other: Vector4<N>): Vector4<N>

operator fun <N> N.times(other: Vector<N>): Vector<N>

operator fun <N> Vector2<N>.times(other: N): Vector2<N>

operator fun <N> Vector3<N>.times(other: N): Vector3<N>

operator fun <N> Vector4<N>.times(other: N): Vector4<N>

operator fun <N> Vector<N>.times(other: N): Vector<N>

operator fun <N> Vector2<N>.unaryMinus(): Vector2<N>

operator fun <N> Vector3<N>.unaryMinus(): Vector3<N>

operator fun <N> Vector4<N>.unaryMinus(): Vector4<N>

operator fun <N> Vector<N>.unaryMinus(): Vector<N>

fun <N> Vector(coordinates: MDList1<N>): Vector<N>

fun <N> Vector(vararg coordinates: N): Vector<N>

fun <N> Vector(size: UInt, initializer: (coordinate: UInt) -> N): Vector<N>

fun <N> Vector2(coordinates: MDList1<N>): Vector2<N>

fun <N> Vector2(x: N, y: N): Vector2<N>

fun <N> Vector3(coordinates: MDList1<N>): Vector3<N>

fun <N> Vector3(x: N, y: N): Vector3<N>

fun <N> Vector4(coordinates: MDList1<N>): Vector4<N>

fun <N> Vector4(x: N, y: N): Vector4<N>