kone.computationalGeometry/dev.lounres.kone.computationalGeometry.utils

Package-level declarations

Functions

all

inline fun <E> Point<E>.all(block: (value: E) -> Boolean): Boolean

inline fun <E> Vector<E>.all(block: (value: E) -> Boolean): Boolean

allIndexed

inline fun <E> Point<E>.allIndexed(block: (index: UInt, value: E) -> Boolean): Boolean

inline fun <E> Vector<E>.allIndexed(block: (index: UInt, value: E) -> Boolean): Boolean

any

inline fun <E> Point<E>.any(block: (value: E) -> Boolean): Boolean

inline fun <E> Vector<E>.any(block: (value: E) -> Boolean): Boolean

anyIndexed

inline fun <E> Point<E>.anyIndexed(block: (index: UInt, value: E) -> Boolean): Boolean

inline fun <E> Vector<E>.anyIndexed(block: (index: UInt, value: E) -> Boolean): Boolean

cross

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

fold

inline fun <E, R> Point<E>.fold(initial: R, operation: (acc: R, E) -> R): R

inline fun <E, R> Vector<E>.fold(initial: R, operation: (acc: R, E) -> R): R

foldIndexed

inline fun <E, R> Point<E>.foldIndexed(initial: R, operation: (index: UInt, acc: R, E) -> R): R

inline fun <E, R> Vector<E>.foldIndexed(initial: R, operation: (index: UInt, acc: R, E) -> R): R

forEach

inline fun <E> Point<E>.forEach(block: (value: E) -> Unit)

inline fun <E> Vector<E>.forEach(block: (value: E) -> Unit)

forEachIndexed

inline fun <E> Point<E>.forEachIndexed(block: (index: UInt, value: E) -> Unit)

inline fun <E> Vector<E>.forEachIndexed(block: (index: UInt, value: E) -> Unit)

inTriangle

fun <N> Point2<N>.inTriangle(P: Point2<N>, Q: Point2<N>, R: Point2<N>): Boolean

map

inline fun <E, R> Point<E>.map(transform: (E) -> R): Point<R>

inline fun <E, R> Vector<E>.map(transform: (E) -> R): Vector<R>

mapIndexed

inline fun <E, R> Point<E>.mapIndexed(transform: (index: UInt, E) -> R): Point<R>

inline fun <E, R> Vector<E>.mapIndexed(transform: (index: UInt, E) -> R): Vector<R>

none

inline fun <E> Point<E>.none(block: (value: E) -> Boolean): Boolean

inline fun <E> Vector<E>.none(block: (value: E) -> Boolean): Boolean

noneIndexed

inline fun <E> Point<E>.noneIndexed(block: (index: UInt, value: E) -> Boolean): Boolean

inline fun <E> Vector<E>.noneIndexed(block: (index: UInt, value: E) -> Boolean): Boolean

sum

fun <E> Point<E>.sum(): E

fun <E> Vector<E>.sum(): E

sumOf

inline fun <E, A> Point<E>.sumOf(selector: (E) -> A): A

inline fun <E, A> Vector<E>.sumOf(selector: (E) -> A): A

sumOfIndexed

inline fun <E, A> Point<E>.sumOfIndexed(selector: (index: UInt, E) -> A): A

inline fun <E, A> Vector<E>.sumOfIndexed(selector: (index: UInt, E) -> A): A

withEach

inline fun <E> Point<E>.withEach(block: E.() -> Unit)

inline fun <E> Vector<E>.withEach(block: E.() -> Unit)

withEachIndexed

inline fun <E> Point<E>.withEachIndexed(block: E.(index: UInt) -> Unit)

inline fun <E> Vector<E>.withEachIndexed(block: E.(index: UInt) -> Unit)