Timeline/gov.nasa.ammos.aerie.procedural.timeline.collections.profiles/Numbers

Numbers

data class Numbers<N : Number>(timeline: Timeline<Segment<N>, Numbers<N>>) : Timeline<Segment<N>, Numbers<N>> , SerialNumericOps<N, Numbers<N>> , PrimitiveNumberOps<N, Numbers<N>> , SerialConstantOps<N, Numbers<N>>

A profile of piece-wise constant numbers.

Unlike Real, this is not able to vary linearly. Instead, it can contain either a homogeneous (and strictly-typed) collection of any numeric type (i.e. Numbers<Integer> (Java) or Numbers<Int> (Kotlin)), or a heterogeneous collection of all numeric types (i.e. Numbers<Number>).

Unfortunately Kotlin/Java is not smart enough to keep the type information during binary operations. So the sum of two Numbers<Double> objects will become Numbers<Number>, although no precision will be lost.

Constructors

Numbers

constructor(v: N)

constructor(vararg segments: Segment<N>)

constructor(segments: List<Segment<N>>)

constructor(timeline: Timeline<Segment<N>, Numbers<N>>)

Types

Companion

object Companion

Functions

abs

abstract fun abs(): Numbers<N>

(DOC) Calculates the absolute value of this profile.

assignGaps

open infix fun assignGaps(v: N): Numbers<N>

(DOC) Fills in gaps in this profile with a constant value.

open infix fun assignGaps(other: SerialSegmentOps<N, *>): Numbers<N>

(DOC) Fills in gaps in this profile with another profile.

cache

open override fun cache(): Numbers<N>

(DOC) Caches the timeline for all available time.

open override fun cache(opts: CollectOptions): Numbers<N>

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

open override fun cache(bounds: Interval): Numbers<N>

(DOC) A simplified version of cache.

changes

abstract fun changes(): Booleans

(DOC) Returns a Booleans that is true whenever this profile changes, and false or gap everywhere else.

collect

open override fun collect(): List<Segment<N>>

(DOC) Collects the timeline for all available time.

open override fun collect(opts: CollectOptions): List<Segment<N>>

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

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

(DOC) A simplified version of collect.

convert

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

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

decreases

open override fun decreases(): Booleans

(DOC) Returns a Booleans that is true whenever this profile decreases, and false or gap everywhere else.

detectEdges

open fun detectEdges(edgePredicate: NullBinaryOperation<N, N, Boolean?>): Booleans

(DOC) Uses a NullBinaryOperation as a predicate to highlight edges between segments.

div

operator fun div(other: Numbers<*>): Numbers<Number>

Calculates this divided by another primitive numeric profile.

operator fun div(other: Real): Numbers<Number>

Divides this by a linear profile.

operator fun div(n: Number): Numbers<Number>

Divides this by a constant number.

equalTo

open infix fun equalTo(v: N): Booleans

(DOC) Returns a Booleans that is true when this equals a constant value.

open infix fun equalTo(other: SerialConstantOps<N, *>): Booleans

(DOC) Returns a Booleans that is true when this and another profile are equal.

filter

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

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

filterByDuration

open fun filterByDuration(validInterval: Interval): Numbers<N>

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

filterByWindows

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

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

filterLongerThan

open fun filterLongerThan(dur: Duration): Numbers<N>

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

filterShorterThan

open fun filterShorterThan(dur: Duration): Numbers<N>

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

flatMap2OptionalValues

open fun <W : Any> flatMap2OptionalValues(other: SerialSegmentOps<W, *>, op: NullBinaryOperation<N, W, SerialSegmentOps<N, *>?>): Numbers<N>

(DOC) Performs a local binary operation that produces profiles, and flattens it into a profile of the same type as this.

open fun <W : Any, R : Any, RESULT : GeneralOps<Segment<R>, RESULT>> flatMap2OptionalValues(ctor: (Timeline<Segment<R>, RESULT>) -> RESULT, other: SerialSegmentOps<W, *>, op: NullBinaryOperation<N, W, SerialSegmentOps<R, *>?>): RESULT

(DOC) Performs a local binary operation that produces profiles, and flattens it, with special treatment of gaps.

flatMap2Values

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

(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: (N, W, Interval) -> SegmentOps<R, *>?): RESULT

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

flatMapValues

open fun flatMapValues(f: (Segment<N>) -> SegmentOps<N, *>): Numbers<N>

(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<N>) -> 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<N>>)

greaterThan

infix fun greaterThan(other: Numbers<*>): Booleans

Returns a Booleans that is true when this is greater than another primitive numeric profile.

infix fun greaterThan(other: Real): Booleans

Returns a Booleans that is true when this is greater than a linear profile.

infix fun greaterThan(n: Number): Booleans

Returns a Booleans that is true when this is greater than a constant number.

greaterThanOrEqual

infix fun greaterThanOrEqual(n: Number): Booleans

Returns a Booleans that is true when this is greater than or equal to a constant number.

greaterThanOrEqualTo

infix fun greaterThanOrEqualTo(other: Numbers<*>): Booleans

Returns a Booleans that is true when this is greater than or equal to another primitive numeric profile.

infix fun greaterThanOrEqualTo(other: Real): Booleans

Returns a Booleans that is true when this is greater than or equal to a linear profile.

highlight

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

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

highlightEqualTo

open fun highlightEqualTo(value: N): Windows

(DOC) Highlights intervals where the value is equal to a specific value.

increases

open override fun increases(): Booleans

(DOC) Returns a Booleans that is true whenever this profile increases, and false or gap everywhere else.

inspect

open fun inspect(f: Consumer<List<Segment<N>>>): Numbers<N>

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

integrate

open fun integrate(unit: Duration = Duration.SECOND): Real

(DOC) Calculates the integral of this profile, starting from zero.

isolate

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

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

isolateEqualTo

open fun isolateEqualTo(value: N): Universal<Segment<N>>

(DOC) Isolates intervals where the value is equal to a specific value.

iterator

open operator override fun iterator(): Iterator<Segment<N>>

lessThan

infix fun lessThan(other: Numbers<*>): Booleans

Returns a Booleans that is true when this is less than another primitive numeric profile.

infix fun lessThan(other: Real): Booleans

Returns a Booleans that is true when this is less than a linear profile.

infix fun lessThan(n: Number): Booleans

Returns a Booleans that is true when this is less than a constant number.

lessThanOrEqual

infix fun lessThanOrEqual(n: Number): Booleans

Returns a Booleans that is true when this is less than or equal to a constant number.

lessThanOrEqualTo

infix fun lessThanOrEqualTo(other: Numbers<*>): Booleans

Returns a Booleans that is true when this is less than or equal to another primitive numeric profile.

infix fun lessThanOrEqualTo(other: Real): Booleans

Returns a Booleans that is true when this is less than or equal to a linear profile.

map2OptionalValues

open fun <W : Any> map2OptionalValues(other: SerialSegmentOps<W, *>, op: NullBinaryOperation<N, W, N?>): Numbers<N>

(DOC) Performs a local binary operation between two profiles where the result is the same type as this profile.

open fun <W : Any, R : Any, RESULT : GeneralOps<Segment<R>, RESULT>> map2OptionalValues(ctor: (Timeline<Segment<R>, RESULT>) -> RESULT, other: SerialSegmentOps<W, *>, op: NullBinaryOperation<N, W, R?>): RESULT

(DOC) Performs a local binary operation between two profiles, with special treatment of gaps.

map2Values

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

(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: (N, W, Interval) -> R?): RESULT

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

mapValues

open fun mapValues(f: (Segment<N>) -> N): Numbers<N>

(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<N>) -> R): RESULT

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

minus

operator fun minus(other: Numbers<*>): Numbers<Number>

Subtracts another primitive numeric profile from this.

operator fun minus(other: Real): Real

Subtracts a linear profile from this.

operator fun minus(n: Number): Numbers<Number>

Subtracts a constant number from this.

negate

abstract fun negate(): Numbers<N>

(DOC) Negates this profile.

notEqualTo

open infix fun notEqualTo(v: N): Booleans

(DOC) Returns a Booleans that is true when this is not equal to a constant value.

open infix fun notEqualTo(other: SerialConstantOps<N, *>): Booleans

(DOC) Returns a Booleans that is true when this and another profile are not equal.

plus

operator fun plus(other: Numbers<*>): Numbers<Number>

Adds this and another primitive numeric profile.

operator fun plus(other: Real): Real

Adds this and a linear profile.

operator fun plus(n: Number): Numbers<Number>

Adds this a constant number.

pow

infix fun pow(exp: Numbers<*>): Numbers<Double>

Calculates this raised to the power of another primitive numeric profile.

infix fun pow(other: Real): Numbers<Double>

Raises this to the power of a linear profile.

infix fun pow(n: Number): Numbers<Double>

Raises this to the power of a constant number.

sample

open fun sample(time: Duration): N?

(DOC) Calculates the value of the profile at the given time.

select

open fun select(interval: Interval): Numbers<N>

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

set

open infix fun set(other: SerialSegmentOps<N, *>): Numbers<N>

(DOC) Overwrites this profile with another. Gaps in the argument profile will be filled in with this profile.

shift

open fun shift(dur: Duration): Numbers<N>

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

shiftedDifference

open override fun shiftedDifference(range: Duration): Numbers<N>

(DOC) Calculates the difference between this profile's value at range time in the future, and this profile at the present.

split

open fun split(f: (Segment<N>) -> Int): Numbers<N>

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

splitEqualTo

open fun splitEqualTo(value: N, numPieces: Int): Numbers<N>

(DOC) Splits segments where the value is equal to a specific value.

spliterator

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

times

operator fun times(other: Numbers<*>): Numbers<Number>

Multiplies this and another primitive numeric profile.

operator fun times(other: Real): Real

Multiplies this by a linear profile.

operator fun times(n: Number): Numbers<Number>

Multiplies this by a constant number.

toBytes

open fun toBytes(): Numbers<Byte>

(DOC) Converts all numbers in the profile to bytes.

toDoubles

open fun toDoubles(): Numbers<Double>

(DOC) Converts all numbers in the profile to doubles.

toFloats

open fun toFloats(): Numbers<Float>

(DOC) Converts all numbers in the profile to floats.

toInts

open fun toInts(): Numbers<Int>

(DOC) Converts all numbers in the profile to ints.

toLongs

open fun toLongs(): Numbers<Long>

(DOC) Converts all numbers in the profile to longs.

toNumbers

open override fun toNumbers(message: String?): Numbers<N>

(DOC) Converts the profile to a constant numbers profile, a.k.a. Numbers (no-op if it already was Numbers).

toReal

open override fun toReal(): Real

(DOC) Converts the profile to a linear profile, a.k.a. Real (no-op if it already was linear).

toShorts

open fun toShorts(): Numbers<Short>

(DOC) Converts all numbers in the profile to shorts.

transitions

open fun transitions(from: N, to: N): Booleans

(DOC) Returns a Booleans that is true when this profile's value changes between two specific values.

unaryMinus

open operator fun unaryMinus(): Numbers<N>

unsafeCast

open override fun <RESULT : Timeline<Segment<N>, RESULT>> unsafeCast(ctor: (Timeline<Segment<N>, 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<N>) -> 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<N>) -> Segment<N>): Numbers<N>

(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<N>) -> 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<N>, W, Interval) -> R?): RESULT

Performs a generalized binary operation between this and another timeline.

unsafeMapIntervals

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

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

unsafeOperate

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

(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<N>, Numbers<N>>.(opts: CollectOptions) -> List<R>): RESULT

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

unset

open fun unset(reject: Interval): Numbers<N>

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

zip

open infix fun zip(other: SerialSegmentOps<N, *>): Numbers<N>

Overlays two profiles on each other, asserting that they both cannot be defined at the same time.

Numbers

See also

Constructors

Types

Functions