korlibs-datastructure/korlibs.math.geom/PointArrayList

PointArrayList

open class PointArrayList(capacity: Int = 7) : PointList, Extra

Constructors

PointArrayList

constructor(capacity: Int = 7)

Types

Companion

object Companion

PointSortOpts

object PointSortOpts : SortOps<PointArrayList>

Properties

closed

open override var closed: Boolean

dimensions

open override val dimensions: Int

extra

open override var extra: ExtraType

first

open val first: Point

last

open val last: Point

size

open override val size: Int

Functions

add

fun ~~add~~(p: IPointList): PointArrayList

fun add(p: Point): PointArrayList

fun add(p: PointList, index: Int)

fun add(x: Double, y: Double): PointArrayList

fun add(x: Float, y: Float): PointArrayList

fun add(x: Int, y: Int): PointArrayList

fun add(p: PointList, index: Int, indexEnd: Int)

addAll

fun addAll(p: IPointList): PointArrayList

addRaw

fun addRaw(vararg values: Double)

fun addRaw(vararg values: Float)

Adds points with values in the format of interleaved (x, y) values.

addReverse

fun addReverse(p: IPointList): PointArrayList

asFakeMutable

fun <K> Collection<K>.asFakeMutable(): FakeMutableCollection<K>

associateByInt

fun <T> Iterable<T>.associateByInt(block: (index: Int, value: T) -> Int): IntMap<T>

clear

fun clear(): PointArrayList

clone

open override fun clone(out: PointArrayList = PointArrayList(this.size)): PointArrayList

contains

open operator override fun contains(p: Point): Boolean

open fun contains(x: Double, y: Double): Boolean

open fun contains(x: Float, y: Float): Boolean

open fun contains(x: Int, y: Int): Boolean

containsAll

open override fun containsAll(elements: Collection<Point>): Boolean

copyFrom

fun copyFrom(other: PointList): PointArrayList

countMap

fun <T> List<T>.countMap(): Map<T, Int>

equals

open operator override fun equals(other: Any?): Boolean

fastForEach

inline fun <T> List<T>.fastForEach(callback: (T) -> Unit)

inline fun PointList.fastForEach(block: (Point) -> Unit)

fastForEachIndexed

inline fun PointList.fastForEachIndexed(block: (index: Int, Point) -> Unit)

fastForEachReverse

inline fun <T> List<T>.fastForEachReverse(callback: (T) -> Unit)

inline fun PointList.fastForEachReverse(block: (Point) -> Unit)

fastForEachReverseIndexed

inline fun PointList.fastForEachReverseIndexed(block: (index: Int, Point) -> Unit)

fastForEachWithIndex

inline fun <T> List<T>.fastForEachWithIndex(callback: (index: Int, value: T) -> Unit)

fastForEachWithTemp

inline fun <T> List<T>.fastForEachWithTemp(temp: FastArrayList<T>, callback: (T) -> Unit)

fastRandom

inline fun <T> Collection<T>.fastRandom(): T

flatten

fun List<PointList>.flatten(): PointList

genericSorted

fun <T : Comparable<T>> List<T>.genericSorted(left: Int = 0, right: Int = size - 1): List<T>

get

open operator override fun get(index: Int): Point

open operator override fun get(index: Int, dim: Int): Double

getComponentList

open fun getComponentList(component: Int, out: DoubleArray = DoubleArray(size)): DoubleArray

getCyclic

fun <T> List<T>.getCyclic(index: Int): T

getCyclicOrNull

fun <T> List<T>.getCyclicOrNull(index: Int): T?

getGeneric

open fun getGeneric(index: Int): GenericDoubleVector

getOrElse

inline fun DoubleVectorList.getOrElse(index: Int, dim: Int, default: Double = 0.0): Double

getX

open override fun getX(index: Int): Double

getX

fun DoubleVectorList.getX(index: Int): Double

getY

open override fun getY(index: Int): Double

getY

fun DoubleVectorList.getY(index: Int): Double

getZ

fun DoubleVectorList.getZ(index: Int): Double

hashCode

open override fun hashCode(): Int

indexOf

open override fun indexOf(element: Point): Int

insertAt

fun insertAt(index: Int, p: PointArrayList): PointArrayList

fun insertAt(index: Int, point: Point): PointArrayList

fun insertAt(index: Int, x: Double, y: Double): PointArrayList

isAlmostEquals

open override fun isAlmostEquals(other: IDoubleVectorList, epsilon: Double): Boolean

isEmpty

open override fun isEmpty(): Boolean

isNotEmpty

open fun isNotEmpty(): Boolean

iterator

open operator override fun iterator(): Iterator<Point>

lastIndexOf

open override fun lastIndexOf(element: Point): Int

listIterator

open override fun listIterator(): ListIterator<Point>

open override fun listIterator(index: Int): ListIterator<Point>

map

fun <T> PointList.map(gen: (x: Double, y: Double) -> T): List<T>

mapDouble

inline fun <T> Iterable<T>.mapDouble(callback: (T) -> Double): DoubleArrayList

mapFloat

inline fun <T> Iterable<T>.mapFloat(callback: (T) -> Float): FloatArrayList

mapInt

inline fun <T> Iterable<T>.mapInt(callback: (T) -> Int): IntArrayList

mapPoints

fun PointList.mapPoints(gen: (Point) -> Point): PointList

mapVector

fun <T> DoubleVectorList.mapVector(block: (list: DoubleVectorList, index: Int) -> T): List<T>

multisorted

fun <T> Iterable<T>.multisorted(vararg props: KProperty1<T, Comparable<*>>): List<T>

orientationScreen

open fun orientationScreen(): Orientation

orientationStd

open fun orientationStd(): Orientation

orientationWithUp

open fun orientationWithUp(up: Vector2D): Orientation

parallelMap

inline fun <T, R> List<T>.parallelMap(crossinline transform: (T) -> R): List<R>

parallelMapInt

inline fun <T> List<T>.parallelMapInt(crossinline transform: (T) -> Int): IntArray

plus

open operator fun plus(other: PointList): PointArrayList

plusAssign

operator fun plusAssign(other: PointList)

operator fun plusAssign(other: Point)

reader

fun <T> List<T>.reader(): ListReader<T>

removeAt

fun removeAt(index: Int, count: Int = 1): PointArrayList

fun removeFirst()

fun removeLast()

fun reverse()

fun <T> List<T>.rotated(offset: Int): List<T>

rotatedLeft

fun <T> List<T>.rotatedLeft(offset: Int = +1): List<T>

rotatedRight

fun <T> List<T>.rotatedRight(offset: Int = +1): List<T>

roundDecimalPlaces

open fun roundDecimalPlaces(places: Int, out: PointArrayList = PointArrayList()): PointList

set

operator fun set(index: Int, p: Point)

setToRoundDecimalPlaces

fun PointArrayList.setToRoundDecimalPlaces(places: Int): PointArrayList

setX

fun setX(index: Int, x: Double)

fun setX(index: Int, x: Float)

fun setX(index: Int, x: Int)

setXY

fun setXY(index: Int, p: Point)

fun setXY(index: Int, x: Double, y: Double)

fun setXY(index: Int, x: Float, y: Float)

fun setXY(index: Int, x: Int, y: Int)

setY

fun setY(index: Int, y: Double)

fun setY(index: Int, y: Float)

fun setY(index: Int, y: Int)

sort

fun sort()

subList

open override fun subList(fromIndex: Int, toIndex: Int): List<Point>

sumOfDouble

@JvmName(name = "sumOfFloat")

inline fun <T> Iterable<T>.sumOfDouble(selector: (T) -> Double): Double

sumOfFloat

@JvmName(name = "sumOfFloat")

inline fun <T> Iterable<T>.sumOfFloat(selector: (T) -> Float): Float

swap

fun swap(indexA: Int, indexB: Int)

timSorted

fun <T : Comparable<T>> List<T>.timSorted(): List<T>

toDeque

fun <T> Collection<T>.toDeque(): Deque<T>

toDoubleList

inline fun Iterable<Double>.toDoubleList(): DoubleArrayList

toFloatList

inline fun Iterable<Float>.toFloatList(): FloatArrayList

toIntList

inline fun Iterable<Int>.toIntList(): IntArrayList

toIntMap

fun <T> Collection<Pair<Int, T>>.toIntMap(): IntMap<T>

toLinkedMap

fun <K, V> Iterable<Pair<K, V>>.toLinkedMap(): LinkedHashMap<K, V>

toList

open fun toList(): List<Point>

toPointArrayList

fun IPointList.toPointArrayList(): PointArrayList

fun List<Point>.toPointArrayList(): PointArrayList

toString

open override fun toString(): String

transform

fun transform(matrix: Matrix)

withoutSortedDuplicates

fun <T> List<T>.withoutSortedDuplicates(out: ArrayList<T> = arrayListOf()): List<T>