kumulant

asDiscrete

fun <R : Result> SeriesStatSpec<R>.asDiscrete(): DiscreteStatSpec<R>(source)

Adapt a series spec into a discrete spec - the discrete sees value.toLong() per update.

asSeries

fun <R : Result> DiscreteStatSpec<R>.asSeries(): SeriesStatSpec<R>(source)

Adapt a discrete spec into a series spec - the series sees value.toDouble() per update.

atIndex

fun <R : Result> SeriesStatSpec<R>.atIndex(index: Int): VectorStatSpec<R>(source)

Adapt a series spec into a vector spec by consuming the index-th coordinate of each vector.

atIndices

fun <R : Result> PairedStatSpec<R>.atIndices(indexX: Int, indexY: Int): VectorStatSpec<R>(source)

Adapt a paired spec into a vector spec by consuming the indexX / indexY coordinates.

atX

fun <R : Result> SeriesStatSpec<R>.atX(): PairedStatSpec<R>(source)

Adapt a series spec into a paired spec by consuming the x component of each pair.

atY

fun <R : Result> SeriesStatSpec<R>.atY(): PairedStatSpec<R>(source)

Adapt a series spec into a paired spec by consuming the y component of each pair.

band

fun SeriesStatSpec<*>.band(k: Double): SeriesStatSpec<BandResult>(source)

Wrap this series spec to expose a [lower, upper] band of width k * scale around center.

derivative

fun <R : Result> SeriesStatSpec<R>.derivative(): SeriesStatSpec<R>(source)

Wrap this series spec to forward the per-second time derivative of the value stream.

diff

fun <R : Result> SeriesStatSpec<R>.diff(k: Int = 1): SeriesStatSpec<R>(source)

Wrap this series spec to forward the k-th difference value - value[t - k].

filter

fun <R : Result> SeriesStatSpec<R>.filter(pred: BoolExpr): SeriesStatSpec<R>(source)

Wrap this series spec so updates are forwarded only when pred evaluates true.

fun <R : Result> DiscreteStatSpec<R>.filter(pred: BoolExpr): DiscreteStatSpec<R>(source)

Wrap this discrete spec so updates are forwarded only when pred evaluates true.

fun <R : Result> PairedStatSpec<R>.filter(pred: BoolExpr): PairedStatSpec<R>(source)

Wrap this paired spec so updates are forwarded only when pred evaluates true on (x, y).

fun <R : Result> VectorStatSpec<R>.filter(pred: BoolExpr): VectorStatSpec<R>(source)

Wrap this vector spec so updates are forwarded only when pred evaluates true on the full vector.

fun <R : Result> RegressionStatSpec<R>.filter(pred: BoolExpr): RegressionStatSpec<R>(source)

Wrap this regression spec so updates are forwarded only when pred evaluates true.

foldPaired

fun <R : Result> SeriesStatSpec<R>.foldPaired(expr: ScalarExpr): PairedStatSpec<R>(source)

Lift this series spec to a paired spec, reducing every (x, y) to a scalar via expr.

foldRegression

fun <R : Result> SeriesStatSpec<R>.foldRegression(featureSize: Int, project: ScalarExpr): RegressionStatSpec<R>(source)

Lift this series spec into the regression modality. project reduces each (x = V, y = Y) update to a scalar that the inner series stat absorbs. Use Y for the marginal-y view.

foldVector

fun <R : Result> SeriesStatSpec<R>.foldVector(expr: ScalarExpr): VectorStatSpec<R>(source)

Lift this series spec to a vector spec, reducing every vector to a scalar via expr.

fun <R : Result> PairedStatSpec<R>.foldVector(xExpr: ScalarExpr, yExpr: ScalarExpr): VectorStatSpec<R>(source)

Lift this paired spec to a vector spec, reducing every vector to a pair (xExpr, yExpr) of scalars via xExpr and yExpr.

hysteresis

fun <R : Result> SeriesStatSpec<R>.hysteresis(low: Double, high: Double): SeriesStatSpec<R>(source)

Wrap this series spec to debounce its input into a 0.0/1.0 stream via two-threshold hysteresis.

lag

fun <R : Result> SeriesStatSpec<R>.lag(k: Int): SeriesStatSpec<R>(source)

Wrap this series spec to forward the value seen k updates ago.

minMaxScaleFeatures

fun <R : Result> VectorStatSpec<R>.minMaxScaleFeatures(dimensions: Int, targetLow: Double = 0.0, targetHigh: Double = 1.0): VectorStatSpec<R>(source)

Element-wise min-max scale a vector spec against a hidden per-coordinate Range primary.

fun <R : Result> RegressionStatSpec<R>.minMaxScaleFeatures(targetLow: Double = 0.0, targetHigh: Double = 1.0): RegressionStatSpec<R>(source)

Element-wise min-max scale a regression spec's feature vector.

minMaxScaler

fun <R : Result> PairedStatSpec<R>.minMaxScaler(targetLow: Double = 0.0, targetHigh: Double = 1.0): PairedStatSpec<R>(source)

Min-max scale both axes of a paired spec against per-axis Range primaries.

fun <R : Result> SeriesStatSpec<R>.minMaxScaler(targetLow: Double = 0.0, targetHigh: Double = 1.0): SeriesStatSpec<R>(source)

Min-max scale the input against a hidden Range primary into [targetLow, targetHigh], then forward the mapped value to this spec. Defaults map to [0, 1]; pass targetLow = -1.0, targetHigh = 1.0 for a [-1, 1] mapping. Emits targetLow while the running range is still degenerate.

resampleByTime

fun <R : Result> SeriesStatSpec<R>.resampleByTime(bucketMillis: Long, aggregator: ResampleAggregator = ResampleAggregator.Mean): SeriesStatSpec<R>(source)

Wrap this series spec to forward one per-bucket summary using aggregator.

sample

fun <R : Result> SeriesStatSpec<R>.sample(rate: Double, seed: Long): SeriesStatSpec<R>(source)

Wrap this series spec to keep each update with probability rate; seed feeds the PRNG.

fun <R : Result> PairedStatSpec<R>.sample(rate: Double, seed: Long): PairedStatSpec<R>(source)

Wrap this paired spec to keep each update with probability rate; seed feeds the PRNG.

fun <R : Result> VectorStatSpec<R>.sample(rate: Double, seed: Long): VectorStatSpec<R>(source)

Wrap this vector spec to keep each update with probability rate; seed feeds the PRNG.

fun <R : Result> DiscreteStatSpec<R>.sample(rate: Double, seed: Long): DiscreteStatSpec<R>(source)

Wrap this discrete spec to keep each update with probability rate; seed feeds the PRNG.

fun <R : Result> RegressionStatSpec<R>.sample(rate: Double, seed: Long): RegressionStatSpec<R>(source)

Wrap this regression spec to keep each update with probability rate; seed feeds the PRNG.

standardScaleFeatures

fun <R : Result> VectorStatSpec<R>.standardScaleFeatures(dimensions: Int): VectorStatSpec<R>(source)

Element-wise standardise a vector spec against a hidden per-coordinate Variance primary.

fun <R : Result> RegressionStatSpec<R>.standardScaleFeatures(): RegressionStatSpec<R>(source)

Element-wise standardise a regression spec's feature vector.

standardScaler

fun <R : Result> PairedStatSpec<R>.standardScaler(): PairedStatSpec<R>(source)

Z-score both axes of a paired spec against per-axis Variance primaries.

fun <R : Result> SeriesStatSpec<R>.standardScaler(): SeriesStatSpec<R>(source)

Z-score the input against a hidden Variance primary, then forward the standardized value to this spec. Emits 0 while the running variance is still zero.

throttle

fun <R : Result> SeriesStatSpec<R>.throttle(every: Int): SeriesStatSpec<R>(source)

Wrap this series spec so it only sees one in every every updates.

fun <R : Result> PairedStatSpec<R>.throttle(every: Int): PairedStatSpec<R>(source)

Wrap this paired spec so it only sees one in every every updates.

fun <R : Result> VectorStatSpec<R>.throttle(every: Int): VectorStatSpec<R>(source)

Wrap this vector spec so it only sees one in every every updates.

fun <R : Result> DiscreteStatSpec<R>.throttle(every: Int): DiscreteStatSpec<R>(source)

Wrap this discrete spec so it only sees one in every every updates.

fun <R : Result> RegressionStatSpec<R>.throttle(every: Int): RegressionStatSpec<R>(source)

Wrap this regression spec so it only sees one in every every updates.

transform

fun <R : Result> SeriesStatSpec<R>.transform(expr: ScalarExpr): SeriesStatSpec<R>(source)

Wrap this series spec to apply expr to every update before the inner stat sees it.

fun <R : Result> DiscreteStatSpec<R>.transform(expr: ScalarExpr): DiscreteStatSpec<R>(source)

Wrap this discrete spec to apply expr to every update before the inner stat sees it.

transformElement

fun <R : Result> VectorStatSpec<R>.transformElement(expr: ScalarExpr): VectorStatSpec<R>(source)

Wrap this vector spec to apply expr to every element of each incoming vector before update.

transformPair

fun <R : Result> PairedStatSpec<R>.transformPair(xExpr: ScalarExpr, yExpr: ScalarExpr): PairedStatSpec<R>(source)

Wrap this paired spec so each (x, y) is remapped via xExpr/yExpr before the inner stat sees it.

transformVector

fun <R : Result> VectorStatSpec<R>.transformVector(expr: VectorExpr): VectorStatSpec<R>(source)

Wrap this vector spec so each incoming vector is remapped through expr before update.

transformX

fun <R : Result> PairedStatSpec<R>.transformX(expr: ScalarExpr): PairedStatSpec<R>(source)

Map only the x coordinate; y stays as-is.

fun <R : Result> RegressionStatSpec<R>.transformX(expr: VectorExpr): RegressionStatSpec<R>(source)

Wrap this regression spec so x is remapped by expr before the inner stat sees it.

transformY

fun <R : Result> PairedStatSpec<R>.transformY(expr: ScalarExpr): PairedStatSpec<R>(source)

Map only the y coordinate; x stays as-is.

fun <R : Result> RegressionStatSpec<R>.transformY(expr: ScalarExpr): RegressionStatSpec<R>(source)

Wrap this regression spec so y is remapped by expr before the inner stat sees it.

vectorized

fun <R : Result> SeriesStatSpec<R>.vectorized(dimensions: Int, skipZeros: Boolean = false): VectorStatSpec<ResultList<R>>(source)

Lift a series spec to a vector spec by replicating it across every coordinate of an N-dim input.

weightBy

fun <R : Result> SeriesStatSpec<R>.weightBy(expr: ScalarExpr): SeriesStatSpec<R>(source)

Wrap this series spec so every update's weight is multiplied by expr.eval(value).

fun <R : Result> PairedStatSpec<R>.weightBy(expr: ScalarExpr): PairedStatSpec<R>(source)

Wrap this paired spec so every update's weight is multiplied by expr.eval(x, y).

fun <R : Result> VectorStatSpec<R>.weightBy(expr: ScalarExpr): VectorStatSpec<R>(source)

Wrap this vector spec so every update's weight is multiplied by expr.eval(0, 0, vec).

fun <R : Result> DiscreteStatSpec<R>.weightBy(expr: ScalarExpr): DiscreteStatSpec<R>(source)

Wrap this discrete spec so every update's weight is multiplied by expr.eval(value.toDouble()).

fun <R : Result> RegressionStatSpec<R>.weightBy(expr: ScalarExpr): RegressionStatSpec<R>(source)

Wrap this regression spec so every update's weight is multiplied by expr.eval(0, y, v).

windowed

fun <R : Result> SeriesStatSpec<R>.windowed(durationMillis: Long, slices: Int = 10): SeriesStatSpec<R>(source)

Wrap this series spec in a sliding time window of durationMillis split into slices buckets.

fun <R : Result> PairedStatSpec<R>.windowed(durationMillis: Long, slices: Int = 10): PairedStatSpec<R>(source)

Wrap this paired spec in a sliding time window of durationMillis split into slices buckets.

fun <R : Result> VectorStatSpec<R>.windowed(durationMillis: Long, slices: Int = 10): VectorStatSpec<R>(source)

Wrap this vector spec in a sliding time window of durationMillis split into slices buckets.

fun <R : Result> DiscreteStatSpec<R>.windowed(durationMillis: Long, slices: Int = 10): DiscreteStatSpec<R>(source)

Wrap this discrete spec in a sliding time window of durationMillis split into slices buckets.

withFeedback

fun <R : Result> SeriesStatSpec<R>.withFeedback(primary: SeriesStatSpec<*>, project: ScalarExpr): SeriesStatSpec<R>(source)

Wrap this inner series spec with a feedback primary; the projection AST sees the primary snapshot.

withFixedX

fun <R : Result> PairedStatSpec<R>.withFixedX(fixedX: Double): SeriesStatSpec<R>(source)

Adapt a paired spec into a series spec by pinning x to fixedX.

withFixedY

fun <R : Result> PairedStatSpec<R>.withFixedY(fixedY: Double): SeriesStatSpec<R>(source)

Adapt a paired spec into a series spec by pinning y to fixedY.

withSelfLag

fun <R : Result> PairedStatSpec<R>.withSelfLag(k: Int): SeriesStatSpec<R>(source)

Lift a paired spec into a series spec by self-pairing each input with the value seen k updates ago.

withTimeAsX

fun <R : Result> PairedStatSpec<R>.withTimeAsX(): SeriesStatSpec<R>(source)

Adapt a paired spec into a series spec by using the update timestamp as x.

withTimeAsY

fun <R : Result> PairedStatSpec<R>.withTimeAsY(): SeriesStatSpec<R>(source)

Adapt a paired spec into a series spec by using the update timestamp as y.

withValue

fun <R : Result> SeriesStatSpec<R>.withValue(value: Double): SeriesStatSpec<R>(source)

Wrap this series spec so every update pushes the constant value regardless of input.

fun <R : Result> DiscreteStatSpec<R>.withValue(value: Long): DiscreteStatSpec<R>(source)

Wrap this discrete spec so every update pushes the constant value regardless of input.

withWeight

fun <R : Result> SeriesStatSpec<R>.withWeight(weight: Double): SeriesStatSpec<R>(source)

Wrap this series spec so every update applies the per-observation weight multiplier.

fun <R : Result> PairedStatSpec<R>.withWeight(weight: Double): PairedStatSpec<R>(source)

Wrap this paired spec so every update applies the per-observation weight multiplier.

fun <R : Result> VectorStatSpec<R>.withWeight(weight: Double): VectorStatSpec<R>(source)

Wrap this vector spec so every update applies the per-observation weight multiplier.

fun <R : Result> DiscreteStatSpec<R>.withWeight(weight: Double): DiscreteStatSpec<R>(source)

Wrap this discrete spec so every update applies the per-observation weight multiplier.

fun <R : Result> RegressionStatSpec<R>.withWeight(weight: Double): RegressionStatSpec<R>(source)

Wrap this regression spec so every update uses weight regardless of caller input.