kumulant/com.eignex.kumulant.schema

schema

Typed, named, wire-portable schemas for declaring bags of stats. A StatSchema does three things:

Lets you read results back by typed StatKey instead of by string.
Materialises into a StatGroup that fans every update out to every registered stat.
Round-trips on the wire as a StatSchemaDef so a remote process can stand up the same bag, run it independently, and ship snapshots back to merge.

Declaring a schema

val telemetry = object : StatSchema(concurrency = Concurrency.Strict) {<br>    val latencyMean by series(Mean)<br>    val errorRate by series(Rate)<br>}<br>val group = StatGroup(telemetry)<br>group.update(42.0)<br>val results = group.read()<br>println(results[telemetry.latencyMean].mean)

The series, paired, vector, and discrete declarators register a StatSpec of the matching modality and return a StatKey carrying the result type. The delegate gives you a typed property; you read results by passing the key back to the group's GroupResult. The group declarator nests a sub-schema, whose entries materialise as their own StatGroup keyed by the outer name.

Specs

Every concrete stat has a sibling StatSpec: a data class (or data object for parameter-less stats) carrying only configuration. Specs are @Serializable with @SerialName discriminators matching the Kotlin class names, so polymorphic serialization puts the same type strings on the wire regardless of format (JSON, CBOR, Protobuf).

Construction lives separately from declaration. Calling spec.materialize(concurrency) builds the live stat. The schema layer calls this for you when you build a StatGroup from a schema.

Specs carry no Concurrency. The concurrency mode is a deployment knob passed at materialize time, so the same wire payload can run at Concurrency.None in a single-threaded test and Concurrency.Strict in a contended hot loop.

Composing specs

Every operation in com.eignex.kumulant.operation has a spec form. The lambda-bound operations (filter, transform, transformPair, foldVector, foldPaired) take an AST on the spec side so the projection / predicate travels as data:

val positiveMean = Mean.filter(X gt 0.0).withWeight(0.5).windowed(1.minutes)

The AST DSL covers comparison (gt, ge, lt, le, eq), boolean combinators (and, or), and arithmetic on X, Y, V(index), and Const(v). Sugar nodes such as Switch, In, Standardize, and MinMax make per-feature projection AST trees readable. Anything that cannot be expressed in the AST stays live-only.

Running a group

StatGroup is itself a com.eignex.kumulant.core.SeriesStat over GroupResult. It can be nested inside another stat, windowed, or merged with another group's GroupResult. PairedStatGroup, VectorStatGroup, and DiscreteStatGroup variants fan updates only to entries of the matching modality.

Shipping over the wire

val spec: StatSpec = Mean<br>val json = SchemaJson.encodeToString(spec)<br>val decoded = SchemaJson.decodeFromString<StatSpec>(json)<br>val live = (decoded as SeriesStatSpec<WeightedMeanResult>).materialize(Concurrency.None)<br>live.update(1.0)

The materializeSeries, materializePaired, materializeVector, and materializeDiscrete variants enforce that every entry matches the expected modality. The unfiltered materialize returns a list of bound stats and leaves the caller to split.

Merging across processes

Each Result is a serializable data class. A common pattern is to have many workers run the same StatGroup, periodically call read on the group, and ship the GroupResult (or its per-entry results) back to a coordinator. The coordinator runs its own StatGroup of the same shape and folds each worker's snapshot in with merge. Because merge takes a Result rather than a live com.eignex.kumulant.core.Stat, the boundary is serialisation-friendly and the worker is free to terminate after each report.

Optimizers

Linear-model stats (com.eignex.kumulant.stat.regression.glm.StochasticRegressionStat, com.eignex.kumulant.stat.regression.SoftmaxRegressionStat) take an OptimizerSpec that materialises into an com.eignex.kumulant.stat.regression.Optimizer. The wire variants are Sgd, Adagrad, Rmsprop, and Adam.

Types

AbstractStatGroup

sealed class AbstractStatGroup<S : Stat<*>> : GroupedStat

Internal base shared by StatGroup, PairedStatGroup, and VectorStatGroup. Holds the spec list and provides the modality-agnostic read / merge / reset implementations.

Accuracy

@Serializable

@SerialName(value = "Accuracy")

data object Accuracy : PairedStatSpec<WeightedMeanResult>

Spec for AccuracyStat: weighted classification accuracy over (predictedClass, trueClass).

Adagrad

@Serializable

@SerialName(value = "Adagrad")

data class Adagrad(val learningRate: ScalarExpr = ConstantRate(0.01), val epsilon: Double = 1.0E-10) : OptimizerSpec

Adagrad. Per-coordinate adaptive learning rate via accumulated squared gradients: w[i] -= lr * grad[i] / sqrt(sumG2[i] + epsilon).

Adam

@Serializable

@SerialName(value = "Adam")

data class Adam(val learningRate: ScalarExpr = ConstantRate(0.001), val beta1: Double = 0.9, val beta2: Double = 0.999, val epsilon: Double = 1.0E-8) : OptimizerSpec

Adam. Bias-corrected first and second moments per coordinate (Kingma & Ba 2015); the general-purpose default in modern online learning. Per-coordinate update:

Adwin

@Serializable

@SerialName(value = "Adwin")

data class Adwin(val delta: Double = 0.002, val maxBucketsPerSize: Int = 5) : SeriesStatSpec<AdwinResult>

Spec for AdwinStat: ADWIN2 adaptive-windowing change detector.

Alpha

@Serializable

@SerialName(value = "Alpha")

data class Alpha(val alpha: Double) : DecayWeightingSpec

Per-observation decay: each new sample carries weight alpha against the running estimate.

Auc

@Serializable

@SerialName(value = "Auc")

data class Auc(val numBins: Int = 256, val lowerBound: Double = 0.0, val upperBound: Double = 1.0) : PairedStatSpec<AucResult>

Spec for AucStat: streaming AUC over a fixed-resolution score histogram.

BayesianRegression

@Serializable

@SerialName(value = "BayesianRegression")

data class BayesianRegression(val featureSize: Int, val priorVariance: Double = 1.0, val link: Link = Link.Identity) : RegressionStatSpec<CovarianceRegressionResult>

Spec for BayesianRegressionStat: closed-form Gaussian linear regression with isotropic prior.

BernoulliSum

@Serializable

@SerialName(value = "BernoulliSum")

data object BernoulliSum : SeriesStatSpec<BernoulliSumResult>

Spec for BernoulliSumStat: weighted count of nonzero inputs.

BloomFilter

@Serializable

@SerialName(value = "BloomFilter")

data class BloomFilter(val bits: Int = 1 shl 16, val hashes: Int = 7, val hasher: HasherRef = HasherRef.SplitMix64) : DiscreteStatSpec<BloomFilterResult>

Spec for BloomFilterStat: probabilistic set membership.

BoolExpr

@Serializable

sealed interface BoolExpr

Wire-serialisable AST for boolean predicates over the same input environment as ScalarExpr. Consumed by every spec-side filter operator and by IfExpr's condition slot.

BoundStat

data class BoundStat<R : Result, S : Stat<R>, K : StatKey<R>>(val key: K, val stat: S)

Pairs a StatKey with the live Stat that produces results for that slot. The combination is what a StatGroup / ListStats actually holds; the key for typed lookup, the stat for accumulation. Carries three type parameters so the key's R / S / K match without erasure shenanigans at the call site:

BrierScore

@Serializable

@SerialName(value = "BrierScore")

data object BrierScore : PairedStatSpec<WeightedMeanResult>

Spec for BrierScoreStat: mean squared error against y in {0, 1} for probabilistic predictions.

Center

@Serializable

@SerialName(value = "Center")

data object Center : ScalarExpr

Reads the center field of the feedback primary's snapshot. Requires the primary's result to implement HasCenterScale; raises IllegalStateException when evaluated without a primary, or when the primary's result does not expose a center.

ConfusionMatrix

@Serializable

@SerialName(value = "ConfusionMatrix")

data class ConfusionMatrix(val numClasses: Int) : PairedStatSpec<ConfusionMatrixResult>

Spec for ConfusionMatrixStat: K-by-K weighted confusion matrix over (predictedClass, trueClass).

Const

@Serializable

@SerialName(value = "Const")

data class Const(val v: Double) : ScalarExpr

Wire spec for a constant scalar.

Count

@Serializable

@SerialName(value = "Count")

data object Count : SeriesStatSpec<SumResult>

Spec for CountStat: unweighted observation count.

CounterRate

@Serializable

@SerialName(value = "CounterRate")

data class CounterRate(val treatDecreaseAsReset: Boolean = true) : SeriesStatSpec<RateResult>

Spec for CounterRateStat: rate inferred from a monotonically increasing counter.

CountMinSketch

@Serializable

@SerialName(value = "CountMinSketch")

data class CountMinSketch(val depth: Int = 5, val width: Int = 1024, val seed: Long = -7046029254386353133L, val hasher: HasherRef = HasherRef.SplitMix64) : DiscreteStatSpec<CountMinSketchResult>

Spec for CountMinSketchStat: approximate frequency table for unbounded-cardinality streams.

Covariance

@Serializable

@SerialName(value = "Covariance")

data object Covariance : PairedStatSpec<CovarianceResult>

Spec for CovarianceStat: weighted covariance and Pearson correlation between two streams.

Crossing

@Serializable

@SerialName(value = "Crossing")

data class Crossing(val level: Double) : SeriesStatSpec<CrossingResult>

Spec for CrossingStat: counts upward and downward crossings of a configured level.

Cusum

@Serializable

@SerialName(value = "Cusum")

data class Cusum(val target: Double = 0.0, val referenceValue: Double = 0.5, val threshold: Double = 5.0) : SeriesStatSpec<CusumResult>

Spec for CusumStat: two-sided cumulative-sum change-point detector.

DDSketch

@Serializable

@SerialName(value = "DDSketch")

data class DDSketch(val relativeError: Double = 0.01, val probabilities: List<Double> = listOf(0.5, 0.75, 0.9, 0.95, 0.99, 0.999)) : SeriesStatSpec<SketchResult>

Spec for DDSketchStat. probabilities is a List on the wire because most formats serialize lists more cleanly than primitive arrays; converted to a DoubleArray at materialize time.

DecayingMean

@Serializable

@SerialName(value = "DecayingMean")

data class DecayingMean(val weighting: HalfLife) : SeriesStatSpec<DecayingMeanResult>

Spec for DecayingMeanStat: time-decayed running mean with HalfLife weighting.

DecayingRate

@Serializable

@SerialName(value = "DecayingRate")

data class DecayingRate(val halfLifeMillis: Long) : SeriesStatSpec<DecayingRateResult>

Spec for DecayingRateStat: events-per-second with exponential time decay.

DecayingSum

@Serializable

@SerialName(value = "DecayingSum")

data class DecayingSum(val weighting: HalfLife) : SeriesStatSpec<DecayingSumResult>

Spec for DecayingSumStat: time-decayed running sum with HalfLife weighting.

DecayingVariance

@Serializable

@SerialName(value = "DecayingVariance")

data class DecayingVariance(val weighting: HalfLife) : SeriesStatSpec<DecayingVarianceResult>

Spec for DecayingVarianceStat: time-decayed running variance with HalfLife weighting.

DecayWeightingSpec

@Serializable

sealed interface DecayWeightingSpec

Wire-friendly counterpart of DecayWeighting. The two strategies are split by field type rather than discriminated union so each decay-stat spec can statically constrain itself to the right strategy (e.g. DecayingSum only accepts HalfLife).

DecisionTreeClassifier

@Serializable

@SerialName(value = "DecisionTreeClassifier")

data class DecisionTreeClassifier(val featureSize: Int, val numClasses: Int, val splitCandidates: List<Split>, val config: ClassificationTreeConfig = ClassificationTreeConfig(), val randomSeed: Int = 0) : RegressionStatSpec<TreeClassificationResult>

Spec for DecisionTreeClassifierStat: online VFDT classification tree.

DecisionTreeRegression

@Serializable

@SerialName(value = "DecisionTreeRegression")

data class DecisionTreeRegression(val featureSize: Int, val splitCandidates: List<Split>, val config: RegressionTreeConfig = RegressionTreeConfig(), val randomSeed: Int = 0) : RegressionStatSpec<TreeRegressionResult>

Spec for DecisionTreeRegressionStat: online VFDT regression tree.

DiagonalRegression

@Serializable

@SerialName(value = "DiagonalRegression")

data class DiagonalRegression(val featureSize: Int, val priorPrecision: Double = 1.0, val learningRate: ScalarExpr = ConstantRate(1.0), val penalty: Penalty = Penalty.None, val link: Link = Link.Identity) : RegressionStatSpec<DiagonalRegressionResult>

Spec for DiagonalRegressionStat: factorised-Gaussian posterior with per-coordinate precision.

DiscreteStatGroup

class DiscreteStatGroup(stats: List<BoundStat<*, out DiscreteStat<*>, *>>, concurrency: Concurrency? = null) : AbstractStatGroup<DiscreteStat<*>> , DiscreteStat<GroupResult>

StatGroup variant over discrete (Long) inputs.

DiscreteStatSpec

@Serializable

sealed interface DiscreteStatSpec<R : Result> : StatSpec

StatSpec that materializes into a com.eignex.kumulant.core.DiscreteStat with result type R.

EwmaMean

@Serializable

@SerialName(value = "EwmaMean")

data class EwmaMean(val weighting: Alpha) : SeriesStatSpec<WeightedMeanResult>

Spec for EwmaMeanStat: exponentially-weighted moving average with per-observation Alpha.

EwmaVariance

@Serializable

@SerialName(value = "EwmaVariance")

data class EwmaVariance(val weighting: Alpha) : SeriesStatSpec<WeightedVarianceResult>

Spec for EwmaVarianceStat: exponentially-weighted moving variance with per-observation Alpha.

Excursion

@Serializable

@SerialName(value = "Excursion")

data object Excursion : SeriesStatSpec<ExcursionResult>

Spec for ExcursionStat: running peak with the largest peak-to-trough excursion observed.

FrugalQuantile

@Serializable

@SerialName(value = "FrugalQuantile")

data class FrugalQuantile(val q: Double, val stepSize: Double = 0.01, val initialEstimate: Double = 0.0) : SeriesStatSpec<QuantileResult>

Spec for FrugalQuantileStat: O(1)-memory single-quantile estimator.

GaussianNaiveBayes

@Serializable

@SerialName(value = "GaussianNaiveBayes")

data class GaussianNaiveBayes(val featureSize: Int, val numClasses: Int, val varianceFloor: Double = 1.0E-9) : RegressionStatSpec<GaussianNaiveBayesResult>

Spec for GaussianNaiveBayesStat: online Gaussian naive Bayes classifier.

GaussianScorer

@Serializable

@SerialName(value = "GaussianScorer")

data object GaussianScorer : SeriesStatSpec<GaussianScoreResult>

Spec for GaussianScorerStat: running mean / variance with |x - mean| / stdDev z-score.

GroupedStat

interface GroupedStat : Stat<GroupResult>

Marker interface for stats whose result is a GroupResult. Implemented by StatGroup and its modality variants. Used in the group declarator below to enforce that nested-group entries actually produce GroupResult rather than some other Result shape.

GroupResult

@Serializable

@SerialName(value = "GroupResult")

data class GroupResult(val results: Map<String, Result>) : Result

Aggregated snapshot of a StatGroup: a map from StatKey.name to the per-slot Result. Backs the result side of the schema layer; use the get(StatKey) operators below for type-safe lookup rather than going through results by string key.

GroupStatKey

class GroupStatKey<K>(name: String, val keys: K) : StatKey<GroupResult>

Specialised StatKey for nested-group slots. The keys field exposes the nested schema's own StatKeys by reference, so dotted lookup composes:

GroupStatSpec

@Serializable

@SerialName(value = "GroupStatSpec")

data class GroupStatSpec(val stats: Map<String, StatSpec>) : SeriesStatSpec<GroupResult>

Serializable spec for a nested series-modality StatGroup. Holds a recursive map of StatSpec entries keyed by name; every entry must itself be a SeriesStatSpec; materialization happens in StatFactory.kt.

HalfLife

@Serializable

@SerialName(value = "HalfLife")

data class HalfLife(val durationMillis: Long) : DecayWeightingSpec

Wall-clock half-life decay: weight halves every durationMillis.

HalfSpaceTrees

@Serializable

@SerialName(value = "HalfSpaceTrees")

data class HalfSpaceTrees(val featureSize: Int, val featureRanges: List<FeatureRange>, val numTrees: Int = 25, val height: Int = 8, val windowSize: Int = 250, val randomSeed: Int = 0) : VectorStatSpec<HalfSpaceTreesResult>

Spec for HalfSpaceTreesStat: online ensemble of random half-space trees for multivariate anomaly scoring.

HdrHistogram

@Serializable

@SerialName(value = "HdrHistogram")

data class HdrHistogram(val lowestDiscernibleValue: Double = 0.001, val initialHighestTrackableValue: Double = 100.0, val significantDigits: Int = 3) : SeriesStatSpec<SparseHistogramResult>

Spec for HdrHistogramStat: high-dynamic-range histogram.

High

@Serializable

@SerialName(value = "High")

data object High : ScalarExpr

Reads the max field of the feedback primary's snapshot. Requires the primary's result to implement HasMinMax; raises IllegalStateException when evaluated without such a primary.

Holt

@Serializable

@SerialName(value = "Holt")

data class Holt(val alphaWeighting: Alpha, val betaWeighting: Alpha = alphaWeighting, val phi: Double = 1.0) : SeriesStatSpec<HoltResult>

Spec for HoltStat: double exponential smoothing with optional trend damping.

HyperLogLog

@Serializable

@SerialName(value = "HyperLogLog")

data class HyperLogLog(val precision: Int = 14, val hasher: HasherRef = HasherRef.SplitMix64) : DiscreteStatSpec<HyperLogLogResult>

Spec for HyperLogLogStat: cardinality sketch with controllable precision.

IfExpr

@Serializable

@SerialName(value = "IfExpr")

data class IfExpr(val cond: BoolExpr, val then: ScalarExpr, val otherwise: ScalarExpr) : ScalarExpr

Wire spec for a ternary if (cond) then else otherwise.

@Serializable

@SerialName(value = "In")

data class In(val of: ScalarExpr, val values: List<Double>) : BoolExpr

Membership test: of in values (exact equality). Use it to flatten chains of Eq predicates joined by Or; e.g. VIndex In listOf(0.0, 3.0).

IsotonicCalibrator

@Serializable

@SerialName(value = "IsotonicCalibrator")

data class IsotonicCalibrator(val numBins: Int = 16) : PairedStatSpec<IsotonicCalibratorResult>

Spec for IsotonicCalibratorStat: binned isotonic calibrator over [0, 1].

LinearCounting

@Serializable

@SerialName(value = "LinearCounting")

data class LinearCounting(val bits: Int = 4096, val hasher: HasherRef = HasherRef.SplitMix64) : DiscreteStatSpec<LinearCountingResult>

Spec for LinearCountingStat: cardinality estimator backed by a bitset of bits cells.

LinearHistogram

@Serializable

@SerialName(value = "LinearHistogram")

data class LinearHistogram(val lowerBound: Double, val upperBound: Double, val binCount: Int) : SeriesStatSpec<SparseHistogramResult>

Spec for LinearHistogramStat: fixed-width bins over [lowerBound, upperBound).

LogLoss

@Serializable

@SerialName(value = "LogLoss")

data object LogLoss : PairedStatSpec<WeightedMeanResult>

Spec for LogLossStat: mean negative log-likelihood for binary y with predicted probability x.

Low

@Serializable

@SerialName(value = "Low")

data object Low : ScalarExpr

Reads the min field of the feedback primary's snapshot. Requires the primary's result to implement HasMinMax; raises IllegalStateException when evaluated without such a primary.

Mad

@Serializable

@SerialName(value = "Mad")

data class Mad(val compression: Double = 100.0) : SeriesStatSpec<MadResult>

Spec for MadStat: streaming median and median absolute deviation via two t-digests.

MaeLoss

@Serializable

@SerialName(value = "MaeLoss")

data object MaeLoss : PairedStatSpec<WeightedMeanResult>

Spec for MaeLossStat: mean absolute error |y - yhat|.

Max

@Serializable

@SerialName(value = "Max")

data object Max : SeriesStatSpec<MaxResult>

Spec for MaxStat: running maximum.

Mean

@Serializable

@SerialName(value = "Mean")

data object Mean : SeriesStatSpec<WeightedMeanResult>

Spec for MeanStat: weighted running mean.

Min

@Serializable

@SerialName(value = "Min")

data object Min : SeriesStatSpec<MinResult>

Spec for MinStat: running minimum.

MinHash

@Serializable

@SerialName(value = "MinHash")

data class MinHash(val numHashes: Int = 128, val seed: Long = -3724518991637283867L, val hasher: HasherRef = HasherRef.SplitMix64) : DiscreteStatSpec<MinHashResult>

Spec for MinHashStat: Jaccard-similarity signature over numHashes independent hash functions.

MinMax

@Serializable

@SerialName(value = "MinMax")

data class MinMax(val targetLow: Double = 0.0, val targetHigh: Double = 1.0) : ScalarExpr

Min-max projection mapping X from [primary.min, primary.max] to [targetLow, targetHigh], emitting targetLow while the running range is still degenerate. Reusable AST sugar for the min-max-scaler pattern; requires a HasMinMax primary.

Moments

@Serializable

@SerialName(value = "Moments")

data object Moments : SeriesStatSpec<MomentsResult>

Spec for MomentsStat: mean / variance / skewness / kurtosis (Welford).

MseLoss

@Serializable

@SerialName(value = "MseLoss")

data object MseLoss : PairedStatSpec<WeightedMeanResult>

Spec for MseLossStat: mean squared error (y - yhat)^2.

OptimizerSpec

@Serializable

sealed interface OptimizerSpec

Wire-portable optimizer strategy. Sealed root of Sgd / Adagrad / Rmsprop / Adam; consumed by the online linear-model stats (com.eignex.kumulant.stat.regression.glm.StochasticRegressionStat, com.eignex.kumulant.stat.regression.SoftmaxRegressionStat) to pick the per-coordinate update rule.

PageHinkley

@Serializable

@SerialName(value = "PageHinkley")

data class PageHinkley(val delta: Double = 0.005, val threshold: Double = 50.0) : SeriesStatSpec<PageHinkleyResult>

Spec for PageHinkleyStat: Page-Hinkley change-point detector.

PairedStatGroup

class PairedStatGroup(stats: List<BoundStat<*, out PairedStat<*>, *>>, concurrency: Concurrency? = null) : AbstractStatGroup<PairedStat<*>> , PairedStat<GroupResult>

StatGroup variant over paired (x, y) inputs.

PairedStatSpec

@Serializable

sealed interface PairedStatSpec<R : Result> : StatSpec

StatSpec that materializes into a com.eignex.kumulant.core.PairedStat with result type R.

PairedSum

@Serializable

@SerialName(value = "PairedSum")

data object PairedSum : PairedStatSpec<PairedSumResult>

Spec for PairedSumStat: tracks per-axis sums of (x, y) updates.

PinballLoss

@Serializable

@SerialName(value = "PinballLoss")

data class PinballLoss(val tau: Double) : PairedStatSpec<WeightedMeanResult>

Spec for PinballLossStat: quantile (pinball) loss at quantile tau.

PitHistogram

@Serializable

@SerialName(value = "PitHistogram")

data class PitHistogram(val numBins: Int) : SeriesStatSpec<SparseHistogramResult>

Spec for pitHistogram(numBins): PIT-style equiprobable histogram for calibration checks.

PlattCalibrator

@Serializable

@SerialName(value = "PlattCalibrator")

data class PlattCalibrator(val optimizer: OptimizerSpec = Sgd(ConstantRate(1e-2))) : PairedStatSpec<PlattCalibratorResult>

Spec for PlattCalibratorStat: one-feature logistic regression fitting sigmoid(a*x + b).

QuantileFilter

@Serializable

@SerialName(value = "QuantileFilter")

data class QuantileFilter(val probability: Double = 0.99, val relativeError: Double = 0.01) : SeriesStatSpec<QuantileFilterResult>

Spec for QuantileFilterStat: DDSketch-backed quantile-threshold anomaly detector.

RandomForestClassifier

@Serializable

@SerialName(value = "RandomForestClassifier")

data class RandomForestClassifier(val featureSize: Int, val numClasses: Int, val splitCandidates: List<Split>, val nbrTrees: Int = 10, val config: ClassificationTreeConfig = ClassificationTreeConfig(), val bagging: Boolean = true, val randomSeed: Int = 0) : RegressionStatSpec<ForestClassificationResult>

Spec for RandomForestClassifierStat: ensembled VFDT classification forest.

RandomForestRegression

@Serializable

@SerialName(value = "RandomForestRegression")

data class RandomForestRegression(val featureSize: Int, val splitCandidates: List<Split>, val nbrTrees: Int = 10, val config: RegressionTreeConfig = RegressionTreeConfig(), val bagging: Boolean = true, val randomSeed: Int = 0) : RegressionStatSpec<ForestRegressionResult>

Spec for RandomForestRegressionStat: ensembled VFDT regression forest.

Range

@Serializable

@SerialName(value = "Range")

data object Range : SeriesStatSpec<RangeResult>

Spec for RangeStat: running min and max as a pair.

Rate

@Serializable

@SerialName(value = "Rate")

data object Rate : SeriesStatSpec<RateResult>

Spec for RateStat: events per second over the observed wall-clock span.

Recency

@Serializable

@SerialName(value = "Recency")

data object Recency : SeriesStatSpec<RecencyResult>

Spec for RecencyStat: time elapsed since the most recent observation.

RecursiveVariance

@Serializable

@SerialName(value = "RecursiveVariance")

data class RecursiveVariance(val omega: Double, val alpha: Double, val beta: Double) : SeriesStatSpec<RecursiveVarianceResult>

Spec for RecursiveVarianceStat: sigma^2_t = omega + alpha * value^2 + beta * sigma^2_{t-1}.

RegressionStatSpec

@Serializable

sealed interface RegressionStatSpec<R : Result> : StatSpec

StatSpec that materializes into a com.eignex.kumulant.core.RegressionStat with result type R.

Reliability

@Serializable

@SerialName(value = "Reliability")

data class Reliability(val numBins: Int) : PairedStatSpec<ReliabilityResult>

Spec for ReliabilityStat: per-bin calibration table (mean predicted vs observed frequency).

ResampleAggregator

@Serializable

enum ResampleAggregator : Enum<ResampleAggregator>

Per-bucket reduction used by the ResampleByTimeSeries spec when aligning an input series onto fixed wall-clock buckets. Configured on a spec; the materializer threads it through to the runtime bucket aggregator.

ReservoirHistogram

@Serializable

@SerialName(value = "ReservoirHistogram")

data class ReservoirHistogram(val capacity: Int = 1024, val seed: Long) : SeriesStatSpec<ReservoirResult>

Configuration for ReservoirHistogramStat. Seed has no default - the live constructor's Random.Default.nextLong() is non-deterministic, which would silently produce different goldens on each instantiation if mirrored here.

Rmsprop

@Serializable

@SerialName(value = "Rmsprop")

data class Rmsprop(val learningRate: ScalarExpr = ConstantRate(0.01), val rho: Double = 0.9, val epsilon: Double = 1.0E-8) : OptimizerSpec

RMSProp. Per-coordinate adaptive learning rate via an exponential moving average of squared gradients: the same shape as Adagrad but with a sliding window instead of a monotone accumulator.

RunLength

@Serializable

@SerialName(value = "RunLength")

data object RunLength : SeriesStatSpec<RunLengthResult>

Spec for RunLengthStat: current and longest consecutive truthy-run lengths.

ScalarExpr

@Serializable

sealed interface ScalarExpr

Wire-serialisable AST for scalar expressions over the per-update input environment. The library uses these wherever a stat needs to apply a caller-supplied projection / weight / threshold expression that has to round-trip on the wire; weightBy, transform, the per-bin scaler projections, the WithFeedback op, the loss / pinball / quantile configurations.

Scale

@Serializable

@SerialName(value = "Scale")

data object Scale : ScalarExpr

Reads the scale field of the feedback primary's snapshot. Requires the primary's result to implement HasCenterScale; raises IllegalStateException when evaluated without a primary, or when the primary's result does not expose a scale.

SeasonalSmoothing

@Serializable

@SerialName(value = "SeasonalSmoothing")

data class SeasonalSmoothing(val alphaWeighting: Alpha, val betaWeighting: Alpha, val gammaWeighting: Alpha, val period: Int, val mode: SeasonalMode = SeasonalMode.Additive, val phi: Double = 1.0) : SeriesStatSpec<SeasonalSmoothingResult>

Spec for SeasonalSmoothingStat: triple exponential smoothing (Holt-Winters).

SeriesStatSpec

@Serializable

sealed interface SeriesStatSpec<R : Result> : StatSpec

StatSpec that materializes into a com.eignex.kumulant.core.SeriesStat with result type R.

Sgd

@Serializable

@SerialName(value = "Sgd")

data class Sgd(val learningRate: ScalarExpr = ConstantRate(1e-3)) : OptimizerSpec

Plain stochastic gradient descent. The default and the cheapest entry; stateless apart from the global step counter feeding the learning-rate schedule. Per-coordinate update: w[i] -= lr(step) * weight * grad[i].

SoftmaxRegression

@Serializable

@SerialName(value = "SoftmaxRegression")

data class SoftmaxRegression(val featureSize: Int, val numClasses: Int, val optimizer: OptimizerSpec = Sgd(), val biasOptimizer: OptimizerSpec = optimizer) : RegressionStatSpec<SoftmaxRegressionResult>

Spec for SoftmaxRegressionStat: multinomial (K-way) logistic regression.

Sojourn

@Serializable

@SerialName(value = "Sojourn")

data class Sojourn(val states: List<Long>) : DiscreteStatSpec<SojournResult>

Spec for SojournStat: per-state time, transition counts, and current dwell over a declared alphabet.

SpaceSaving

@Serializable

@SerialName(value = "SpaceSaving")

data class SpaceSaving(val capacity: Int) : DiscreteStatSpec<HeavyHittersResult>

Spec for SpaceSavingStat: top-capacity heavy-hitters tracker.

Standardize

@Serializable

@SerialName(value = "Standardize")

data object Standardize : ScalarExpr

Z-score projection: (X - Center) / Scale, emitting 0 when Scale is still zero. Reusable AST sugar for the standard-scaler pattern; requires a HasCenterScale primary.

StatGroup

class StatGroup(stats: List<BoundStat<*, out SeriesStat<*>, *>>, concurrency: Concurrency? = null) : AbstractStatGroup<SeriesStat<*>> , SeriesStat<GroupResult>

Fans each update out to a heterogeneous list of SeriesStats and reports their results keyed by name.

StatKey

open class StatKey<R : Result>(val name: String)

Typed handle to one entry in a StatSchema / GroupResult. Carries the result type R as a phantom type so reading back from a GroupResult produces a typed value rather than an Any:

StatSchema

abstract class StatSchema(val concurrency: Concurrency = Concurrency.None) : Schema<StatSpec>

Declarative, typed schema for a group of stats, layered on top of com.eignex.skema.Schema<StatSpec> so the entries map is wire-serializable.

StatSchemaDef

@Serializable

data class StatSchemaDef(val stats: Map<String, StatSpec>)

Pure-data, serializable form of a StatSchema. The wire field is stats (kumulant convention, customised over skema's default entries). Decode an incoming wire payload into this type and rehydrate a live group via materializeSeries (or one of the modality-specific variants).

StatSpec

@Serializable

sealed interface StatSpec

Pure-data recipe for a com.eignex.kumulant.core.Stat. Each variant is a data class (or data object for parameter-less stats) whose fields are exactly the stat's configuration surface - no live cells, no locks, no com.eignex.kumulant.core.Concurrency.

StochasticRegression

@Serializable

@SerialName(value = "StochasticRegression")

data class StochasticRegression(val featureSize: Int, val optimizer: OptimizerSpec = Sgd(), val biasOptimizer: OptimizerSpec = optimizer, val penalty: Penalty = Penalty.None, val link: Link = Link.Identity) : RegressionStatSpec<StochasticRegressionResult>

Spec for StochasticRegressionStat: online GLM with a configurable optimizer.

Sum

@Serializable

@SerialName(value = "Sum")

data object Sum : SeriesStatSpec<SumResult>

Spec for SumStat: weighted running sum.

Summary

@Serializable

@SerialName(value = "Summary")

data object Summary : SeriesStatSpec<SummaryResult>

Spec for SummaryStat: mean / variance / min / max in one result, useful as a primary for mixed-scaler feedback projections.

Switch

@Serializable

@SerialName(value = "Switch")

data class Switch(val on: ScalarExpr, val cases: List<SwitchCase>, val otherwise: ScalarExpr) : ScalarExpr

Multi-way branch on a scalar key. Replaces nested IfExpr cascades. The first case whose SwitchCase.value equals on.eval(...) exactly wins; if none match, otherwise is returned.

SwitchCase

@Serializable

@SerialName(value = "SwitchCase")

data class SwitchCase(val value: Double, val then: ScalarExpr)

One case of a Switch expression: when on evaluates to value (exact equality), the result is then. Exact double equality is fine for integer-valued keys like VIndex; not recommended for general continuous comparisons.

TDigest

@Serializable

@SerialName(value = "TDigest")

data class TDigest(val compression: Double = 100.0, val probabilities: List<Double> = listOf(0.5, 0.75, 0.9, 0.95, 0.99, 0.999)) : SeriesStatSpec<TDigestResult>

Spec for TDigestStat: streaming t-digest quantile sketch.

ThresholdBucket

@Serializable

@SerialName(value = "ThresholdBucket")

data class ThresholdBucket(val thresholds: List<Double>) : SeriesStatSpec<ThresholdBucketResult>

Spec for ThresholdBucketStat: weighted counts per user-defined value bucket.

TotalWeights

@Serializable

@SerialName(value = "TotalWeights")

data object TotalWeights : SeriesStatSpec<SumResult>

Spec for TotalWeightsStat: cumulative observation weight.

UnivariateRegression

@Serializable

@SerialName(value = "UnivariateRegression")

data class UnivariateRegression(val penalty: Penalty = Penalty.None) : PairedStatSpec<UnivariateRegressionResult>

Spec for UnivariateRegressionStat: scalar OLS / Lasso / Ridge depending on penalty.

@Serializable

@SerialName(value = "V")

data class V(val index: Int) : ScalarExpr

v[index] - out-of-bounds throws at eval time.

Variance

@Serializable

@SerialName(value = "Variance")

data object Variance : SeriesStatSpec<WeightedVarianceResult>

Spec for VarianceStat: weighted running variance (Welford).

VectorExpr

@Serializable

sealed interface VectorExpr

Wire-serialisable AST for vector-valued expressions over the same input environment as ScalarExpr / BoolExpr. Used by the spec-side transformVector(VectorExpr) operator when the output is a fresh vector rather than a per-element transform.

VectorStatGroup

class VectorStatGroup(stats: List<BoundStat<*, out VectorStat<*>, *>>, concurrency: Concurrency? = null) : AbstractStatGroup<VectorStat<*>> , VectorStat<GroupResult>

StatGroup variant over vector inputs.

VectorStatSpec

@Serializable

sealed interface VectorStatSpec<R : Result> : StatSpec

StatSpec that materializes into a com.eignex.kumulant.core.VectorStat with result type R.

VFoldOp

@Serializable

enum VFoldOp : Enum<VFoldOp>

Reduction over the entire vector input. Distinct from element-level arithmetic (Add, Mul) - this collapses a DoubleArray of arbitrary length to a single scalar via the chosen operation.

VIndex

@Serializable

@SerialName(value = "VIndex")

data object VIndex : ScalarExpr

In element-wise feedback contexts (vector / regression / paired), returns the coordinate index of the currently evaluating element as a Double. Outside such contexts (primary is not an IndexedResult), raises IllegalStateException.

@Serializable

@SerialName(value = "X")

data object X : ScalarExpr

Refers to the primary scalar input x.

@Serializable

@SerialName(value = "Y")

data object Y : ScalarExpr

Refers to the secondary scalar input y (paired stats only).

Functions

and

infix fun BoolExpr.and(rhs: BoolExpr): BoolExpr

Short-circuiting conjunction.

asDiscrete

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

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

asSeries

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

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>

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>

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

atX

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

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>

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

band

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

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>

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>

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

div

operator fun ScalarExpr.div(rhs: ScalarExpr): ScalarExpr

Build Div of two expressions.

operator fun ScalarExpr.div(rhs: Double): ScalarExpr

Divide this expression by a literal rhs.

operator fun Double.div(rhs: ScalarExpr): ScalarExpr

Divide a literal receiver by an expression.

infix fun ScalarExpr.eq(rhs: ScalarExpr): BoolExpr

Exact equality (no tolerance).

infix fun ScalarExpr.eq(rhs: Double): BoolExpr

Exact equality against a literal (no tolerance).

filter

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

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

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

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

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

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

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

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

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

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

foldPaired

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

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>

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>

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>

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

infix fun ScalarExpr.ge(rhs: ScalarExpr): BoolExpr

Greater-or-equal comparison.

infix fun ScalarExpr.ge(rhs: Double): BoolExpr

Greater-or-equal against a literal.

group

inline fun <K, S : GroupedStat> group(name: String, keys: K, build: (K) -> S): BoundStat<GroupResult, S, GroupStatKey<K>>

Build a nested-group BoundStat. build is invoked with keys (the sub-schema's key handle) and must return a GroupedStat; typically a StatGroup constructed against that sub-schema. The resulting BoundStat uses a GroupStatKey so dotted lookup result[outerKey][innerKey] compiles.

infix fun ScalarExpr.gt(rhs: ScalarExpr): BoolExpr

Strictly-greater-than comparison.

infix fun ScalarExpr.gt(rhs: Double): BoolExpr

Strictly-greater-than against a literal.

hysteresis

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

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>

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

infix fun ScalarExpr.le(rhs: ScalarExpr): BoolExpr

Less-or-equal comparison.

infix fun ScalarExpr.le(rhs: Double): BoolExpr

Less-or-equal against a literal.

infix fun ScalarExpr.lt(rhs: ScalarExpr): BoolExpr

Strictly-less-than comparison.

infix fun ScalarExpr.lt(rhs: Double): BoolExpr

Strictly-less-than against a literal.

materialize

fun <R : Result> DiscreteStatSpec<R>.materialize(concurrency: Concurrency = Concurrency.None): DiscreteStat<R>

Construct a live DiscreteStat from a DiscreteStatSpec. See SeriesStatSpec.materialize.

fun <R : Result> PairedStatSpec<R>.materialize(concurrency: Concurrency = Concurrency.None): PairedStat<R>

Construct a live PairedStat from a PairedStatSpec. See SeriesStatSpec.materialize.

fun <R : Result> RegressionStatSpec<R>.materialize(concurrency: Concurrency = Concurrency.None): RegressionStat<R>

Construct a live RegressionStat from a RegressionStatSpec. See SeriesStatSpec.materialize.

fun <R : Result> SeriesStatSpec<R>.materialize(concurrency: Concurrency = Concurrency.None): SeriesStat<R>

Construct a live SeriesStat from a SeriesStatSpec. One when per modality, one cast at the boundary - sealed-hierarchy exhaustiveness keeps the cast safe.

fun StatSchemaDef.materialize(concurrency: Concurrency = Concurrency.None): List<BoundStat<*, *, *>>

Materialize every entry, regardless of modality. Caller filters by stat type.

fun StatSpec.materialize(concurrency: Concurrency = Concurrency.None): Stat<*>

Construct a live stat from any StatSpec, dispatching on its modality. Useful for code paths (like StatSchemaDef.materialize) that iterate over an erased Map<String, StatSpec> and don't statically know the modality.

fun <R : Result> VectorStatSpec<R>.materialize(concurrency: Concurrency = Concurrency.None): VectorStat<R>

Construct a live VectorStat from a VectorStatSpec. See SeriesStatSpec.materialize.

materializeDiscrete

fun StatSchemaDef.materializeDiscrete(concurrency: Concurrency = Concurrency.None): List<BoundStat<*, out DiscreteStat<*>, *>>

Materialize discrete-modality entries only; throws if any entry isn't discrete.

materializePaired

fun StatSchemaDef.materializePaired(concurrency: Concurrency = Concurrency.None): List<BoundStat<*, out PairedStat<*>, *>>

Materialize paired-modality entries only; throws if any entry isn't paired.

materializeSeries

fun StatSchemaDef.materializeSeries(concurrency: Concurrency = Concurrency.None): List<BoundStat<*, out SeriesStat<*>, *>>

Materialize series-modality entries only; throws if any entry isn't series.

materializeVector

fun StatSchemaDef.materializeVector(concurrency: Concurrency = Concurrency.None): List<BoundStat<*, out VectorStat<*>, *>>

Materialize vector-modality entries only; throws if any entry isn't vector.

minMaxScaleFeatures

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

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

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

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

minMaxScaler

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

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>

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.

minus

operator fun ScalarExpr.minus(rhs: ScalarExpr): ScalarExpr

Build Sub of two expressions.

operator fun ScalarExpr.minus(rhs: Double): ScalarExpr

Subtract a literal rhs from this expression.

operator fun Double.minus(rhs: ScalarExpr): ScalarExpr

Subtract an expression from a literal receiver.

not

operator fun BoolExpr.not(): BoolExpr

Logical negation.

infix fun BoolExpr.or(rhs: BoolExpr): BoolExpr

Short-circuiting disjunction.

plus

operator fun ScalarExpr.plus(rhs: ScalarExpr): ScalarExpr

Build Add of two expressions.

operator fun ScalarExpr.plus(rhs: Double): ScalarExpr

Add a literal rhs to this expression.

operator fun Double.plus(rhs: ScalarExpr): ScalarExpr

Add an expression to a literal receiver.

resampleByTime

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

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

sample

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

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

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

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

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

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

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

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

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

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

standardScaleFeatures

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

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

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

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

standardScaler

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

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

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

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.

stat

fun <R : Result, S : Stat<R>, K : StatKey<R>> stat(key: K, value: S): BoundStat<R, S, K>

Build a BoundStat from an existing StatKey and a live stat. Used when the key was created elsewhere (e.g. via a StatSchema declarator) and you want to pair it with a specific live instance; common in tests and in materializer code paths.

fun <R : Result, S : Stat<R>> stat(name: String, value: S): BoundStat<R, S, StatKey<R>>

Build a BoundStat from a string name and a live stat. Convenience for ad-hoc groups: BoundStat(StatKey(name), value) with type inference.

throttle

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

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

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

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

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

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

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

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

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

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

times

operator fun ScalarExpr.times(rhs: ScalarExpr): ScalarExpr

Build Mul of two expressions.

operator fun ScalarExpr.times(rhs: Double): ScalarExpr

Multiply this expression by a literal rhs.

operator fun Double.times(rhs: ScalarExpr): ScalarExpr

Multiply a literal receiver by an expression.

transform

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

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

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

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

transformElement

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

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>

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>

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>

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

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

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>

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

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

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

unaryMinus

operator fun ScalarExpr.unaryMinus(): ScalarExpr

Unary minus: wraps in Neg.

vectorized

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

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

weightBy

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

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

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

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

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

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

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

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

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

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

windowed

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

Wrap this discrete 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>

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

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

Wrap this series 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>

Wrap this vector 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>

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>

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

withFixedY

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

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

withSelfLag

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

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>

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

withTimeAsY

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

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

withValue

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

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

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

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

withWeight

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

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

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

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

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

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

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

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

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

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