kone.misc.planimetricsCalculation/dev.lounres.kone.misc.planimetricsCalculation

Package-level declarations

Types

data class Line<E>(val x: LabeledPolynomial<E>, val y: LabeledPolynomial<E>, val z: LabeledPolynomial<E>)

class PlanimetricsCalculationSpace<Number>(numberRing: Ring<Number>, polynomialSpace: MultivariatePolynomialSpace<Number, LabeledVariable, LabeledPolynomial<Number>> = numberRing.labeledPolynomialSpace, polynomialVectorKategory: VectorKategory<LabeledPolynomial<Number>> = polynomialSpace.vectorKategory())

Point

data class Point<E>(val x: LabeledPolynomial<E>, val y: LabeledPolynomial<E>, val z: LabeledPolynomial<E>)

Quadric

data class Quadric<E>(val xx: LabeledPolynomial<E>, val yy: LabeledPolynomial<E>, val zz: LabeledPolynomial<E>, val xy: LabeledPolynomial<E>, val xz: LabeledPolynomial<E>, val yz: LabeledPolynomial<E>)

Transformation

@JvmInline

value class Transformation<E>(val matrix: Matrix<LabeledPolynomial<E>>)

Properties

isFinite

val <Number> Point<Number>.isFinite: Boolean

Line

val <Number> Line: PlanimetricsCalculationSpace.LineDelegate<Number>

lineAtInfinity

val <Number> lineAtInfinity: Line<Number>

matrix

val <E> Quadric<E>.matrix: Matrix<LabeledPolynomial<E>>

origin

val <Number> origin: Point<Number>

Point

val <Number> Point: PlanimetricsCalculationSpace.PointDelegate<Number>

Quadric

val <Number> Quadric: PlanimetricsCalculationSpace.QuadricDelegate<Number>

xAxis

val <Number> xAxis: Line<Number>

xBasis

val <Number> xBasis: Point<Number>

yAxis

val <Number> yAxis: Line<Number>

yBasis

val <Number> yBasis: Point<Number>

Functions

calculate

inline fun <Number, R> calculate(block: (Ring<Number>, MultivariatePolynomialSpace<Number, LabeledVariable, LabeledPolynomial<Number>>, VectorKategory<LabeledPolynomial<Number>>) -> R): R

center

fun <E> Quadric<E>.center(): Point<E>

centroid

fun <E> centroid(A: Point<E>, B: Point<E>, C: Point<E>): Point<E>

circleByCenterAndPoint

fun <E> circleByCenterAndPoint(O: Point<E>, A: Point<E>): Quadric<E>

circleByDiameter

fun <E> circleByDiameter(A: Point<E>, B: Point<E>): Quadric<E>

circumcenter

fun <E> circumcenter(A: Point<E>, B: Point<E>, C: Point<E>): Point<E>

circumcircle

fun <E> circumcircle(A: Point<E>, B: Point<E>, C: Point<E>): Quadric<E>

cocyclicityCondition

fun <E> cocyclicityCondition(A: Point<E>, B: Point<E>, C: Point<E>, D: Point<E>): LabeledPolynomial<E>

cocyclicityTest

fun <E> cocyclicityTest(A: Point<E>, B: Point<E>, C: Point<E>, D: Point<E>): Boolean

collinearityCondition

fun <E> collinearityCondition(A: Point<E>, B: Point<E>, C: Point<E>): LabeledPolynomial<E>

collinearityTest

fun <E> collinearityTest(A: Point<E>, B: Point<E>, C: Point<E>): Boolean

concurrencyCondition

fun <E> concurrencyCondition(l: Line<E>, m: Line<E>, n: Line<E>): LabeledPolynomial<E>

concurrencyTest

fun <E> concurrencyTest(l: Line<E>, m: Line<E>, n: Line<E>): Boolean

divideSegmentInRatio

fun <E> divideSegmentInRatio(A: Point<E>, B: Point<E>, lambda: E): Point<E>

fun <E> divideSegmentInRatio(A: Point<E>, B: Point<E>, a: E, b: E): Point<E>

dualBy

fun <E> Quadric<E>.dualBy(q: Quadric<E>): Quadric<E>

infix inline fun <E> Transformation<E>.eq(other: Transformation<E>): Boolean

equalsTo

infix inline fun <E> Transformation<E>.equalsTo(other: Transformation<E>): Boolean

eulerCircle

fun <E> eulerCircle(A: Point<E>, B: Point<E>, C: Point<E>): Quadric<E>

eulerLine

fun <E> eulerLine(A: Point<E>, B: Point<E>, C: Point<E>): Line<E>

homothetyBy

fun <E> homothetyBy(P: Point<E>, k: E): Transformation<E>

inPlanimetricsCalculationSpaceFor

fun <N, R> KoneContextRegistry.inPlanimetricsCalculationSpaceFor(numberType: SuppliedType<N>, block: (PlanimetricsCalculationSpace<N>) -> R): R

inPlanimetricsCalculationSpaceScopeFor

fun <N, R> KoneContextRegistry.inPlanimetricsCalculationSpaceScopeFor(numberType: SuppliedType<N>, block: (PlanimetricsCalculationSpace<N>, Equality<Point<N>>, Equality<Line<N>>, Equality<Quadric<N>>) -> R): R

installPlanimetricsCalculationSpaceFor

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

intersectionOf

fun <E> intersectionOf(l: Line<E>, m: Line<E>): Point<E>

invoke

operator fun <E> Transformation<E>.invoke(P: Point<E>): Point<E>

involutionBy

fun <E> involutionBy(l: Line<E>, q: Quadric<E>): Transformation<E>

fun <E> involutionBy(A: Point<E>, l: Line<E>): Transformation<E>

fun <E> involutionBy(A: Point<E>, q: Quadric<E>): Transformation<E>

isCircle

fun <E> Quadric<E>.isCircle(): Boolean

isLyingOn

infix fun <Number> Point<Number>.isLyingOn(l: Line<Number>): Boolean

infix fun <Number> Point<Number>.isLyingOn(q: Quadric<Number>): Boolean

isLyingThrough

infix fun <Number> Line<Number>.isLyingThrough(P: Point<Number>): Boolean

infix fun <Number> Quadric<Number>.isLyingThrough(P: Point<Number>): Boolean

isNotLyingOn

infix fun <Number> Point<Number>.isNotLyingOn(l: Line<Number>): Boolean

infix fun <Number> Point<Number>.isNotLyingOn(q: Quadric<Number>): Boolean

isNotLyingThrough

infix fun <Number> Line<Number>.isNotLyingThrough(P: Point<Number>): Boolean

infix fun <Number> Quadric<Number>.isNotLyingThrough(P: Point<Number>): Boolean

isNotTangentTo

infix fun <Number> Line<Number>.isNotTangentTo(q: Quadric<Number>): Boolean

infix fun <Number> Quadric<Number>.isNotTangentTo(l: Line<Number>): Boolean

isParallelTo

infix inline fun <E> Line<E>.isParallelTo(other: Line<E>): Boolean

isPerpendicularTo

infix inline fun <E> Line<E>.isPerpendicularTo(other: Line<E>): Boolean

isTangentTo

infix fun <Number> Line<Number>.isTangentTo(q: Quadric<Number>): Boolean

infix fun <Number> Quadric<Number>.isTangentTo(l: Line<Number>): Boolean

Line

fun <C> Line(columnVector: ColumnVector<LabeledPolynomial<C>>): Line<C>

fun <C> Line(rowVector: RowVector<LabeledPolynomial<C>>): Line<C>

fun <C> Line(name: String): Line<C>

fun <C> Line(x: C, y: C, z: C): Line<C>

lineEquality

fun <Number> lineEquality(polynomialRing: Ring<LabeledPolynomial<Number>>): Equality<Line<Number>>

lineThrough

fun <Number> lineThrough(P: Point<Number>): ReadOnlyProperty<Any?, Line<Number>>

fun <E> lineThrough(A: Point<E>, B: Point<E>): Line<E>

lyingCondition

fun <Number> lyingCondition(P: Point<Number>, l: Line<Number>): LabeledPolynomial<Number>

fun <Number> lyingCondition(P: Point<Number>, q: Quadric<Number>): LabeledPolynomial<Number>

midpoint

fun <E> midpoint(A: Point<E>, B: Point<E>): Point<E>

neq

infix inline fun <E> Transformation<E>.neq(other: Transformation<E>): Boolean

notEqualsTo

infix inline fun <E> Transformation<E>.notEqualsTo(other: Transformation<E>): Boolean

orthocenter

fun <E> orthocenter(A: Point<E>, B: Point<E>, C: Point<E>): Point<E>

parallelismCondition

fun <E> parallelismCondition(l: Line<E>, m: Line<E>): LabeledPolynomial<E>

parallelismTest

fun <E> parallelismTest(l: Line<E>, m: Line<E>): Boolean

parallelLine

fun <E> parallelLine(l: Line<E>, A: Point<E>): Line<E>

parallelLineThrough

infix inline fun <E> Line<E>.parallelLineThrough(A: Point<E>): Line<E>

parallelLineTo

infix inline fun <E> Point<E>.parallelLineTo(l: Line<E>): Line<E>

perpendicular

fun <E> perpendicular(l: Line<E>, A: Point<E>): Line<E>

perpendicularityCondition

fun <E> perpendicularityCondition(l: Line<E>, m: Line<E>): LabeledPolynomial<E>

perpendicularityTest

fun <E> perpendicularityTest(l: Line<E>, m: Line<E>): Boolean

perpendicularThrough

infix inline fun <E> Line<E>.perpendicularThrough(A: Point<E>): Line<E>

perpendicularTo

infix inline fun <E> Point<E>.perpendicularTo(l: Line<E>): Line<E>

planimetricsCalculationSpace

fun <Number> Ring<Number>.planimetricsCalculationSpace(polynomialSpace: MultivariatePolynomialSpace<Number, LabeledVariable, LabeledPolynomial<Number>> = labeledPolynomialSpace, polynomialVectorKategory: VectorKategory<LabeledPolynomial<Number>> = polynomialSpace.vectorKategory()): PlanimetricsCalculationSpace<Number>

Point

fun <C> Point(columnVector: ColumnVector<LabeledPolynomial<C>>): Point<C>

fun <C> Point(rowVector: RowVector<LabeledPolynomial<C>>): Point<C>

fun <C> Point(name: String): Point<C>

fun <C> Point(x: C, y: C, z: C): Point<C>

pointEquality

fun <Number> pointEquality(polynomialRing: Ring<LabeledPolynomial<Number>>): Equality<Point<Number>>

pointOn

fun <Number> pointOn(L: Line<Number>): ReadOnlyProperty<Any?, Point<Number>>

polarBy

fun <E> Point<E>.polarBy(q: Quadric<E>): Line<E>

poleBy

fun <E> Line<E>.poleBy(q: Quadric<E>): Point<E>

projectOn

fun <E> Point<E>.projectOn(l: Line<E>): Point<E>

projectToQuadricBy

fun <E> Line<E>.projectToQuadricBy(q: Quadric<E>, l: Line<E>): Line<E>

fun <E> Line<E>.projectToQuadricBy(q: Quadric<E>, P: Point<E>): Point<E>

fun <E> Point<E>.projectToQuadricBy(q: Quadric<E>, l: Line<E>): Line<E>

fun <E> Point<E>.projectToQuadricBy(q: Quadric<E>, P: Point<E>): Point<E>

Quadric

fun <C> Quadric(matrix: Matrix<LabeledPolynomial<C>>): Quadric<C>

fun <C> Quadric(name: String): Quadric<C>

quadricByPoints

fun <E> quadricByPoints(P: Point<E>, Q: Point<E>, R: Point<E>, S: Point<E>, T: Point<E>): Quadric<E>

quadricEquality

fun <Number> quadricEquality(polynomialRing: Ring<LabeledPolynomial<Number>>): Equality<Quadric<Number>>

reflectionThrough

fun <E> reflectionThrough(l: Line<E>): Transformation<E>

fun <E> reflectionThrough(P: Point<E>): Transformation<E>

reflectThrough

fun <E> Point<E>.reflectThrough(l: Line<E>): Point<E>

fun <E> Point<E>.reflectThrough(P: Point<E>): Point<E>

segmentBisector

fun <E> segmentBisector(A: Point<E>, B: Point<E>): Line<E>

tangencyCondition

fun <Number> tangencyCondition(l: Line<Number>, q: Quadric<Number>): LabeledPolynomial<Number>