Timeline/gov.nasa.ammos.aerie.procedural.timeline.ops.numeric/LinearOps

LinearOps

interface LinearOps<THIS : LinearOps<THIS>> : NumericOps<LinearEquation, THIS>

Operations mixin for segment-valued timelines whose payloads represent continuous, piecewise linear values.

Currently only used for Real profiles, but in the future could be refactored for duration profiles or parallel real profiles.

Inheritors

Real

Functions

abs

open override fun abs(): THIS

(DOC) Calculates the absolute value of this profile.

cache

open fun cache(): THIS

(DOC) Caches the timeline for all available time.

abstract fun cache(opts: CollectOptions): THIS

Caches the result of collecting this timeline, to be reused for future collect requests if possible.

open fun cache(bounds: Interval): THIS

(DOC) A simplified version of cache.

collect

open fun collect(): List<Segment<LinearEquation>>

(DOC) Collects the timeline for all available time.

abstract fun collect(opts: CollectOptions): List<Segment<LinearEquation>>

(DOC) Evaluates the stack of operations and produces a list of timeline payload objects.

open fun collect(bounds: Interval): List<Segment<LinearEquation>>

(DOC) A simplified version of collect.

convert

open fun <RESULT : GeneralOps<Segment<LinearEquation>, RESULT>> convert(ctor: (Timeline<Segment<LinearEquation>, RESULT>) -> RESULT): RESULT

(DOC) Safely converts to another timeline type that accepts the same payload type.

filter

open fun filter(preserveMargin: Boolean = false, f: (Segment<LinearEquation>) -> Boolean): THIS

(DOC) Removes or retains objects based on a predicate.

filterByDuration

open fun filterByDuration(validInterval: Interval): THIS

(DOC) Removes objects whose duration is outside a given valid interval.

filterByWindows

open fun filterByWindows(windows: SerialOps<Interval, *>, truncateMarginal: Boolean = true): THIS

(DOC) Filters out payload objects whose intervals are not contained in the given Windows timeline.

filterLongerThan

open fun filterLongerThan(dur: Duration): THIS

(DOC) Removes objects whose duration is shorter than a given duration.

filterShorterThan

open fun filterShorterThan(dur: Duration): THIS

(DOC) Removes objects whose duration is longer than a given duration.

flatMap2Values

open fun flatMap2Values(other: SegmentOps<LinearEquation, *>, op: (LinearEquation, LinearEquation, Interval) -> SegmentOps<LinearEquation, *>?): THIS

(DOC) A simpler version of flatMap2Values for operations that don't change the timeline type.

open fun <W : Any, R : Any, RESULT : SegmentOps<R, RESULT>> flatMap2Values(ctor: (Timeline<Segment<R>, RESULT>) -> RESULT, other: SegmentOps<W, *>, op: (LinearEquation, W, Interval) -> SegmentOps<R, *>?): RESULT

(DOC) Performs a local binary operation that produces profiles, and flattens it.

flatMapValues

open fun flatMapValues(f: (Segment<LinearEquation>) -> SegmentOps<LinearEquation, *>): THIS

(DOC) A simpler version of flatMapValues for operations that don't change the timeline type.

open fun <R : Any, RESULT : SegmentOps<R, RESULT>> flatMapValues(ctor: (Timeline<Segment<R>, RESULT>) -> RESULT, f: (Segment<LinearEquation>) -> SegmentOps<R, *>): RESULT

(DOC) Maps segments into a collection of nested timelines and flattens them into their original intervals.

forEach

open fun forEach(p0: Consumer<in Segment<LinearEquation>>)

highlight

open fun highlight(f: (Segment<LinearEquation>) -> Boolean): Windows

(DOC) Similar to filter, but produces a coalesced Windows object that highlights everything that satisfies the predicate.

inspect

open fun inspect(f: Consumer<List<Segment<LinearEquation>>>): THIS

(DOC) Inserts a no-op function into the operation stack to allow side effects, such as printing.

isolate

open fun isolate(f: (Segment<LinearEquation>) -> Boolean): Universal<Segment<LinearEquation>>

(DOC) Similar to filter, but returns an Universal timeline.

iterator

abstract operator fun iterator(): Iterator<Segment<LinearEquation>>

map2Values

open fun map2Values(other: SegmentOps<LinearEquation, *>, op: (LinearEquation, LinearEquation, Interval) -> LinearEquation?): THIS

(DOC) A simplified version of map2Values for operations that don't change the timeline type.

open fun <W : Any, R : Any, RESULT : SegmentOps<R, RESULT>> map2Values(ctor: (Timeline<Segment<R>, RESULT>) -> RESULT, other: SegmentOps<W, *>, op: (LinearEquation, W, Interval) -> R?): RESULT

(DOC) Performs a local binary operation between two segment-valued timelines.

mapValues

open fun mapValues(f: (Segment<LinearEquation>) -> LinearEquation): THIS

(DOC) Locally transforms the values of a profile without changing the intervals or profile type.

open fun <R : Any, RESULT : SegmentOps<R, RESULT>> mapValues(ctor: (Timeline<Segment<R>, RESULT>) -> RESULT, f: (Segment<LinearEquation>) -> R): RESULT

(DOC) Locally transforms the values of a profile without changing the intervals.

negate

open override fun negate(): THIS

(DOC) Negates this profile.

rate

open fun rate(unit: Duration = Duration.SECOND): Numbers<Double>

(DOC) Maps each segment into its derivative.

select

open fun select(interval: Interval): THIS

(DOC) Restricts the timeline to only be evaluated in the given interval.

shift

open override fun shift(dur: Duration): THIS

(DOC) Uniformly shifts the entire timeline in time (positive shifts toward the future).

split

open fun split(f: (Segment<LinearEquation>) -> Int): THIS

(DOC) Splits payload objects into a variable number of equally sized pieces.

spliterator

open fun spliterator(): Spliterator<Segment<LinearEquation>>

unaryMinus

open operator fun unaryMinus(): THIS

unsafeCast

abstract fun <RESULT : Timeline<Segment<LinearEquation>, RESULT>> unsafeCast(ctor: (Timeline<Segment<LinearEquation>, RESULT>) -> RESULT): RESULT

(DOC) UNSAFE! Casts this timeline type to another type without changing its contents.

unsafeFlatMap

open fun <R : IntervalLike<R>, RESULT : GeneralOps<R, RESULT>> unsafeFlatMap(ctor: (Timeline<R, RESULT>) -> RESULT, boundsTransformer: BoundsTransformer, truncate: Boolean, f: (Segment<LinearEquation>) -> Segment<GeneralOps<R, *>>): RESULT

(DOC) UNSAFE! Maps each object to a nested timeline and flattens all the timelines into one.

unsafeMap

open fun unsafeMap(boundsTransformer: BoundsTransformer, truncate: Boolean, f: (Segment<LinearEquation>) -> Segment<LinearEquation>): THIS

(DOC) UNSAFE! A simpler version of unsafeMap for operations that don't change the timeline type.

open fun <R : IntervalLike<R>, RESULT : GeneralOps<R, RESULT>> unsafeMap(ctor: (Timeline<R, RESULT>) -> RESULT, boundsTransformer: BoundsTransformer, truncate: Boolean, f: (Segment<LinearEquation>) -> R): RESULT

(DOC) UNSAFE! Maps each timeline object to another object, of potentially a different type, at potentially a different time.

unsafeMap2

open fun <W : IntervalLike<W>, R : IntervalLike<R>, RESULT : GeneralOps<R, RESULT>> unsafeMap2(ctor: (Timeline<R, RESULT>) -> RESULT, other: GeneralOps<W, *>, op: (Segment<LinearEquation>, W, Interval) -> R?): RESULT

Performs a generalized binary operation between this and another timeline.

unsafeMapIntervals

open fun unsafeMapIntervals(boundsTransformer: BoundsTransformer, truncate: Boolean, f: (Segment<LinearEquation>) -> Interval): THIS

(DOC) UNSAFE! Maps the interval of each object, leaving the rest of the object unchanged.

unsafeOperate

open fun unsafeOperate(f: Timeline<Segment<LinearEquation>, THIS>.(opts: CollectOptions) -> List<Segment<LinearEquation>>): THIS

(DOC) UNSAFE! A simpler version of unsafeOperate for operations that don't change the timeline type.

open fun <R : IntervalLike<R>, RESULT : GeneralOps<R, RESULT>> unsafeOperate(ctor: (Timeline<R, RESULT>) -> RESULT, f: Timeline<Segment<LinearEquation>, THIS>.(opts: CollectOptions) -> List<R>): RESULT

(DOC) UNSAFE! The basic, most general operation method. All operations eventually delegate here.

unset

open fun unset(reject: Interval): THIS

(DOC) Unsets everything in a given interval. Timeline objects whose intervals fully contain the rejected interval may be split into two objects.