Navigation/com.amarcolini.joos.util

Package-level declarations

Miscellaneous utilities

Types

class CircularGVF(val center: Vector2d, val radius: Double, val kN: Double, val errorMapFunc: (Double) -> Double = { it }) : GuidingVectorField

class CompositeGVF(val pathGVF: PathGVF, val obstacles: Iterable<GVFObstacle>, val correctionRadius: Double = 5.0) : FollowableGVF

A composite guiding vector field that avoids obstacles and follows pathGVF.

DoubleProgression

data class DoubleProgression(val start: Double, val step: Double, val size: Int) : Iterable<Double>

A progression of values of type Double.

interface FollowableGVF : GuidingVectorField

GuidingVectorField

interface GuidingVectorField : VectorField

Guiding vector field for effective path following described in section III, eq. (9) of 1610.04391.pdf. Implementation note: the function phi (see eq. (2)) and its properties are split up into Phi.target and Phi.tangent.

class GVFObstacle(val gvf: GuidingVectorField, val insetDistance: Double, val zeroInMapFunc: (Double) -> Double = { defaultMapFunction(it) }, val zeroOutMapFunc: (Double) -> Double = { defaultMapFunction(it) })

An obstacle vector field (\(\mathcal{X}_{\mathcal{R}_i}\) eq. 4) as described in this paper.

class Matrix3x3(a: Double, b: Double, c: Double, d: Double, e: Double, f: Double, g: Double, h: Double, i: Double)

interface NanoClock

Clock interface with nanosecond precision and no guarantee about its origin (that is, this is only suited for measuring relative/elapsed time).

class PathGVF(val path: Path, val kN: Double, val errorMapFunc: (Double) -> Double = { it }) : GuidingVectorField, FollowableGVF

An implementation of GuidingVectorField that follows the specified path.

PositionPathGVF

class PositionPathGVF(val path: PositionPath, val kN: Double, val errorMapFunc: (Double) -> Double = { it }) : GuidingVectorField

interface VectorField

Properties

val Number.deg: Angle

Creates an Angle from the specified value in degrees.

const val EPSILON: Double = 1.0E-6

The accuracy with which epsilonEquals operates : 0.000001.

val Number.rad: Angle

Creates an Angle from the specified value in radians.

Functions

fun abs(angle: Angle): Angle

fun clamp(n: Double, min: Double, max: Double): Double

Ensures that n lies in the range min..max.

fun cos(angle: Angle): Double

doLinearRegression

fun doLinearRegression(x: List<Double>, y: List<Double>): Pair<Double, Double>

Does a linear regression of the form y = mx + b.

doLinearRegressionNoIntercept

fun doLinearRegressionNoIntercept(x: List<Double>, y: List<Double>): Double

Does a linear regression of the form y = mx.

infix fun Double.epsilonEquals(other: Double): Boolean

Returns whether two doubles are approximately equal (within EPSILON).

evaluatePolynomial

fun evaluatePolynomial(polynomial: DoubleArray, x: Double): Double

Evaluates polynomial at x.

generatePascalsTriangle

fun generatePascalsTriangle(n: Int): Array<IntArray>

Generates n rows of Pascal's triangle.

fun isolateRoots(polynomial: DoubleArray, pascalsTriangle: Array<IntArray> = generatePascalsTriangle(polynomial.size)): List<ClosedFloatingPointRange<Double>>

Returns a list of intervals that each contain a root of polynomial that lies in 0, 1. Uses the Modified Uspensky algorithm described here.

fun max(a: Angle, b: Angle): Angle

fun min(a: Angle, b: Angle): Angle

operator fun Double.minus(progression: DoubleProgression): DoubleProgression

operator fun Double.plus(progression: DoubleProgression): DoubleProgression

fun sign(angle: Angle): Double

fun sin(angle: Angle): Double

fun solveQuadratic(a: Double, b: Double, c: Double): List<Double>

Returns the real solutions to the quadratic \(ax^2 + bx + c\).

fun tan(angle: Angle): Double

operator fun Double.times(angle: Angle): Angle

Multiplies angle by the provided scalar.

operator fun Double.times(pose: Pose2d): Pose2d

Multiplies pose by the provided scalar.

operator fun Double.times(vector: Vector2d): Vector2d

Multiplies vector by the provided scalar.

fun wrap(n: Double, min: Double, max: Double): Double

fun wrap(n: Int, min: Int, max: Int): Int

Ensures that n lies in the range min..max, where min and max are modularly-equivalent (that is, n wraps around).

@JvmName(name = "wrap1")

fun Double.wrap(bounds: Pair<Double, Double>): Double

@JvmName(name = "wrap1")

fun Double.wrap(min: Double, max: Double): Double

@JvmName(name = "wrap1")

fun Int.wrap(min: Int, max: Int): Int