🥮 mooncakes.io

moon-change-point

Production-oriented MoonBit change-point detection, streaming windows, multivariate monitoring, replay, SLO and alert routing

change-point
anomaly-detection
time-series
cusum
moon add Zy789kl/moon-change-point@0.2.0
Download zip
Author
Version
0.2.0
License
Apache-2.0
Repository
Last updated
9 hours ago
Downloads
2
README

#moon-change-point

面向生产指标的 MoonBit 变点检测库：在线检测、离线分段、迟到数据重排、多变量监控、回放复现、SLO 与告警路由均可组合使用。

#安装与最小用法

moon add Zy789kl/moon-change-point

///|
import {
  "Zy789kl/moon-change-point" @cp,
}

///|
fn main {
  let detector = @cp.Cusum::new(target_mean=0.0, control_limit=5.0, drift=0.5)
  println(detector.update_result(2.0, index=1).summary())
}

#验收验证

固定种子基准可通过 moon run cmd/main 重现；项目包含 410 个边界、回归和集成测试，实现源码超过 8,000 行，并在稳定版 MoonBit 的多平台 CI 中执行格式、检查、构建、接口和测试验证。

Apache-2.0。仓库：https://github.com/Zy789kl/moon-change-point。

#
AdaptiveBaseline

source
pub struct AdaptiveBaseline {
  moments : OnlineMoments
  value : Double
  learning_rate : Double
  initialized : Bool
}

A slowly adapting baseline for streams whose normal level changes over time.

#
AdaptiveBaseline::new

source
fn AdaptiveBaseline::new(learning_rate? : Double) -> AdaptiveBaseline

#
AdaptiveBaseline::sample_count

source
fn AdaptiveBaseline::sample_count(self : AdaptiveBaseline) -> Int

#
AdaptiveBaseline::summary

source

#
AdaptiveBaseline::update

source
fn AdaptiveBaseline::update(self : AdaptiveBaseline, observation : Double) -> Double

#
AdaptiveBaseline::value

source
fn AdaptiveBaseline::value(self : AdaptiveBaseline) -> Double

#
AdaptiveThreshold

source
pub struct AdaptiveThreshold {
  threshold : Double
  rate : Double
  minimum : Double
  maximum : Double
  count : Int
}

#
AdaptiveThreshold::count

source
fn AdaptiveThreshold::count(self : AdaptiveThreshold) -> Int

#
AdaptiveThreshold::new

source
fn AdaptiveThreshold::new(initial? : Double, rate? : Double, minimum? : Double, maximum? : Double) -> AdaptiveThreshold

#
AdaptiveThreshold::observe

source
fn AdaptiveThreshold::observe(self : AdaptiveThreshold, score : Double, positive : Bool) -> Double

#
AdaptiveThreshold::value

source
fn AdaptiveThreshold::value(self : AdaptiveThreshold) -> Double

#
AggregationKind

source
pub(all) enum AggregationKind {
  MeanAggregate
  SumAggregate
  MinimumAggregate
  MaximumAggregate
  StandardDeviationAggregate
}

Aggregation choices for a fixed streaming window.

#
AlertBudget

source
pub struct AlertBudget {
  capacity : Double
  refill : Double
  tokens : Double
  suppressed : Int
}

#
AlertBudget::allow

source
fn AlertBudget::allow(self : AlertBudget) -> Bool

#
AlertBudget::new

source
fn AlertBudget::new(capacity? : Int, refill? : Double) -> AlertBudget

#
AlertBudget::suppressed

source
fn AlertBudget::suppressed(self : AlertBudget) -> Int

#
AlertBudget::tick

source
fn AlertBudget::tick(self : AlertBudget) -> Unit

#
AlertEvent

source
pub struct AlertEvent {
  metric : String
  point : ChangePoint
  suppressed : Bool
  ordinal : Int
}

A named alert emitted by a multi-series pipeline.

#
AlertEvent::new

source
fn AlertEvent::new(metric : String, point : ChangePoint, suppressed? : Bool, ordinal? : Int) -> AlertEvent

Constructs an alert event.

#
AlertPolicy

source
pub struct AlertPolicy {
  minimum_score : Double
  minimum_confidence : Double
  minimum_gap : Int
  recovery_points : Int
  quiet_points : Int
  healthy_points : Int
}

Controls deduplication, minimum severity, and recovery for one metric.

#
AlertPolicy::accept

source
fn AlertPolicy::accept(self : AlertPolicy, result : DetectionResult) -> Bool

#
AlertPolicy::minimum_score

source
fn AlertPolicy::minimum_score(self : AlertPolicy) -> Double

#
AlertPolicy::new

source
fn AlertPolicy::new(minimum_score? : Double, minimum_confidence? : Double, minimum_gap? : Int, recovery_points? : Int) -> AlertPolicy

#
AlertPolicy::reset

source
fn AlertPolicy::reset(self : AlertPolicy) -> Unit

#
AlertSeverity

source
pub(all) enum AlertSeverity {
  Informational
  Warning
  Critical
}

The severity used by alerting integrations.

#
Ar1Forecaster

source
pub struct Ar1Forecaster {
  mean : Double
  covariance : Double
  variance : Double
  previous : Double
  count : Int
  forgetting : Double
}

#
Ar1Forecaster::new

source
fn Ar1Forecaster::new(forgetting? : Double) -> Ar1Forecaster

#
Ar1Forecaster::update

source
fn Ar1Forecaster::update(self : Ar1Forecaster, value : Double) -> ForecastPoint

#
Bayesian

source
pub struct Bayesian {
  hazard_rate : Double
  run_length_probs : Array[Double]
  mu_t : Array[Double]
  kappa_t : Array[Double]
  alpha_t : Array[Double]
  beta_t : Array[Double]
  mu0 : Double
  kappa0 : Double
  alpha0 : Double
  beta0 : Double
  max_run_length : Int
}

Bayesian implements a simplified Bayesian Online Change Point Detection using a Normal-Gamma conjugate prior.

#
Bayesian::new

source
fn Bayesian::new(hazard_rate? : Double, mu0? : Double, kappa0? : Double, alpha0? : Double, beta0? : Double, max_run_length? : Int) -> Bayesian

Creates a new Bayesian Online Change Point Detector.

#
Bayesian::update

source
fn Bayesian::update(self : Bayesian, value : Double) -> Double

Updates the detector and returns the probability of a change point at the current step.

#
Bayesian::update_result

source
fn Bayesian::update_result(self : Bayesian, value : Double, index? : Int) -> DetectionResult

Rich result form of the Bayesian update.

#
BenchmarkResult

source
pub struct BenchmarkResult {
  name : String
  samples : Int
  passes : Int
  detections : Int
  first_detection : Int
  checksum : Double
  truth_count : Int
  metrics : ChangePointMetrics
}

Results of a deterministic detector benchmark.

#
BenchmarkResult::empty

source
fn BenchmarkResult::empty(name : String) -> BenchmarkResult

#
BenchmarkResult::summary

source
fn BenchmarkResult::summary(self : BenchmarkResult) -> String

#
BootstrapEstimate

source
pub struct BootstrapEstimate {
  mean : Double
  lower : Double
  upper : Double
  standard_error : Double
  replicates : Int
}

#
ChangeDirection

source
pub(all) enum ChangeDirection {
  Increase
  Decrease
  VarianceIncrease
  VarianceDecrease
  DistributionShift
  Unknown
}

The direction of a distributional change.

#
ChangePoint

source
pub struct ChangePoint {
  timestamp : Int64
  index : Int
  score : Double
  confidence : Double
  severity : AlertSeverity
  direction : ChangeDirection
  detector : String
  baseline : Double
  observed : Double
}

A detected change with enough context for a downstream alert or dashboard.

#
ChangePoint::from_result

source
fn ChangePoint::from_result(point : SignalPoint, result : DetectionResult, detector : String, baseline : Double) -> ChangePoint

Creates a change point from an online result.

#
ChangePoint::summary

source
fn ChangePoint::summary(self : ChangePoint) -> String

Returns a stable log line for a change point.

#
ChangePointMetrics

source
pub struct ChangePointMetrics {
  true_positives : Int
  false_positives : Int
  false_negatives : Int
  precision : Double
  recall : Double
  f1 : Double
  mean_detection_delay : Double
}

Quality metrics for a set of predicted change indices.

#
ChangePointMetrics::empty

source

#
ConsecutiveRule

source
pub struct ConsecutiveRule {
  required : Int
  hits : Int
  misses : Int
}

A debouncer that requires several consecutive positive observations.

#
ConsecutiveRule::hits

source
fn ConsecutiveRule::hits(self : ConsecutiveRule) -> Int

#
ConsecutiveRule::new

source
fn ConsecutiveRule::new(required? : Int) -> ConsecutiveRule

#
ConsecutiveRule::push

source
fn ConsecutiveRule::push(self : ConsecutiveRule, positive : Bool) -> Bool

#
Cusum

source
pub struct Cusum {
  target_mean : Double
  control_limit : Double
  drift : Double
  g_positive : Double
  g_negative : Double
  t : Int
}

Cusum implements the Cumulative Sum algorithm for detecting shifts in the mean.

#
Cusum::new

source
fn Cusum::new(target_mean? : Double, control_limit? : Double, drift? : Double) -> Cusum

Creates a new CUSUM detector.

#
Cusum::reset

source
fn Cusum::reset(self : Cusum) -> Unit

Resets the internal accumulators.

#
Cusum::update

source
fn Cusum::update(self : Cusum, value : Double) -> Bool

Updates the CUSUM detector with a new value and returns true if a change is detected.

#
Cusum::update_result

source
fn Cusum::update_result(self : Cusum, value : Double, index? : Int) -> DetectionResult

Rich result form of update, retaining the direction and evidence.

#
DataQualityGate

source
pub struct DataQualityGate {
  minimum_ratio : Double
  reject_non_monotonic : Bool
  reject_dimension_mismatch : Bool
}

#
DataQualityGate::accept

source
fn DataQualityGate::accept(self : DataQualityGate, report : QualityReport) -> Bool

#
DataQualityGate::new

source
fn DataQualityGate::new(minimum_ratio? : Double, reject_non_monotonic? : Bool, reject_dimension_mismatch? : Bool) -> DataQualityGate

#
DetectionExplanation

source
pub struct DetectionExplanation {
  result : DetectionResult
  baseline : Double
  observed : Double
  deviation : Double
  relative_change : Double
  contributions : Array[EvidenceContribution]
  recommendation : String
}

#
DetectionExplanation::empty

source
fn DetectionExplanation::empty(index? : Int) -> DetectionExplanation

#
DetectionResult

source
pub struct DetectionResult {
  changed : Bool
  score : Double
  confidence : Double
  direction : ChangeDirection
  index : Int
  evidence : Double
}

A normalized result returned by online and offline detectors.

#
DetectionResult::new

source
fn DetectionResult::new(changed : Bool, score : Double, confidence : Double, direction : ChangeDirection, index : Int, evidence? : Double) -> DetectionResult

Builds a result while keeping confidence and evidence in a safe range.

#
DetectionResult::quiet

source
fn DetectionResult::quiet(index? : Int) -> DetectionResult

Returns a result that represents an ordinary observation.

#
DetectionResult::summary

source
fn DetectionResult::summary(self : DetectionResult) -> String

Produces a compact representation suitable for logs.

#
Detector

source
pub struct Detector {
  detector : DetectorType
  suppression_count : Int
  suppression_limit : Int
}

Detector wraps a specific algorithm and supports multi-metric alert suppression.

#
Detector::new

source
fn Detector::new(detector : DetectorType, suppression_limit? : Int) -> Detector

Creates a new multi-metric detector wrapper.

#
Detector::update

source
fn Detector::update(self : Detector, value : Double) -> Bool

Updates the detector and handles alert suppression. Returns true if an unsuppressed alert is triggered.

#
Detector::update_result

source
fn Detector::update_result(self : Detector, value : Double, index? : Int) -> DetectionResult

Rich result form of the detector wrapper. Suppression is applied to the change flag only.

#
DetectorSpec

source
pub struct DetectorSpec {
  name : String
  family : String
  online : Bool
  multivariate : Bool
  robust : Bool
  default_threshold : Double
  description : String
}

Public algorithm metadata for dashboards and configuration UIs.

#
DetectorSpec::new

source
fn DetectorSpec::new(name : String, family : String, online : Bool, multivariate : Bool, robust : Bool, default_threshold : Double, description : String) -> DetectorSpec

#
DetectorSpec::summary

source
fn DetectorSpec::summary(self : DetectorSpec) -> String

#
DetectorType

source
pub(all) enum DetectorType {
  CusumDetector(Cusum)
  PageHinkleyDetector(PageHinkley)
  BayesianDetector(Bayesian)
}

DetectorType represents the type of change point detector to use.

#
DeterministicRng

source
pub struct DeterministicRng {
  state : Int64
}

A deterministic pseudo-random source used by benchmarks and reproducible tests.

#
DeterministicRng::new

source
fn DeterministicRng::new(seed? : Int64) -> DeterministicRng

#
DeterministicRng::next

source
fn DeterministicRng::next(self : DeterministicRng) -> Int64

#
DeterministicRng::normalish

source
fn DeterministicRng::normalish(self : DeterministicRng, amplitude? : Double) -> Double

#
DeterministicRng::symmetric

source
fn DeterministicRng::symmetric(self : DeterministicRng) -> Double

#
DeterministicRng::unit

source
fn DeterministicRng::unit(self : DeterministicRng) -> Double

#
DistributionShiftDetector

source
pub struct DistributionShiftDetector {
  reference : DoubleWindow
  current : DoubleWindow
  threshold : Double
  index : Int
}

Compares adjacent windows and emits a distribution-shift result.

#
DistributionShiftDetector::new

source
fn DistributionShiftDetector::new(window_size? : Int, threshold? : Double) -> DistributionShiftDetector

#
DistributionShiftDetector::update

source

#
DoubleWindow

source
pub struct DoubleWindow {
  capacity : Int
  values : Array[Double]
  start : Int
  length : Int
}

A bounded ring buffer for numeric streaming windows.

#
DoubleWindow::capacity

source
fn DoubleWindow::capacity(self : DoubleWindow) -> Int

#
DoubleWindow::clear

source
fn DoubleWindow::clear(self : DoubleWindow) -> Unit

#
DoubleWindow::first

source
fn DoubleWindow::first(self : DoubleWindow) -> Double?

#
DoubleWindow::get

source
fn DoubleWindow::get(self : DoubleWindow, index : Int) -> Double?

#
DoubleWindow::is_empty

source
fn DoubleWindow::is_empty(self : DoubleWindow) -> Bool

#
DoubleWindow::is_full

source
fn DoubleWindow::is_full(self : DoubleWindow) -> Bool

#
DoubleWindow::last

source
fn DoubleWindow::last(self : DoubleWindow) -> Double?

#
DoubleWindow::length

source
fn DoubleWindow::length(self : DoubleWindow) -> Int

#
DoubleWindow::mean

source
fn DoubleWindow::mean(self : DoubleWindow) -> Double

#
DoubleWindow::median

source
fn DoubleWindow::median(self : DoubleWindow) -> Double

#
DoubleWindow::new

source
fn DoubleWindow::new(capacity : Int) -> DoubleWindow

Creates a fixed-capacity window. Non-positive capacities are normalized to one.

#
DoubleWindow::push

source
fn DoubleWindow::push(self : DoubleWindow, value : Double) -> Double?

Adds a value and returns the value evicted from a full window, if any.

#
DoubleWindow::quantile

source
fn DoubleWindow::quantile(self : DoubleWindow, probability : Double) -> Double

#
DoubleWindow::slope

source
fn DoubleWindow::slope(self : DoubleWindow) -> Double

#
DoubleWindow::snapshot

source
fn DoubleWindow::snapshot(self : DoubleWindow) -> StatsSummary

#
DoubleWindow::standard_deviation

source
fn DoubleWindow::standard_deviation(self : DoubleWindow) -> Double

#
DoubleWindow::sum

source
fn DoubleWindow::sum(self : DoubleWindow) -> Double

#
DoubleWindow::to_array

source
fn DoubleWindow::to_array(self : DoubleWindow) -> Array[Double]

#
DoubleWindow::variance

source
fn DoubleWindow::variance(self : DoubleWindow) -> Double

#
DualSidedDetector

source
pub struct DualSidedDetector {
  positive : Cusum
  negative : Cusum
  index : Int
}

#
DualSidedDetector::new

source
fn DualSidedDetector::new(target? : Double, limit? : Double, drift? : Double) -> DualSidedDetector

#
DualSidedDetector::update

source
fn DualSidedDetector::update(self : DualSidedDetector, value : Double) -> DetectionResult

#
EnsembleResult

source
pub struct EnsembleResult {
  result : DetectionResult
  votes : Int
  detector_count : Int
  agreement : Double
}

#
EventHistory

source
pub struct EventHistory {
  capacity : Int
  events : Array[AlertEvent]
  total : Int
}

#
EventHistory::critical_count

source
fn EventHistory::critical_count(self : EventHistory) -> Int

#
EventHistory::events

source
fn EventHistory::events(self : EventHistory) -> Array[AlertEvent]

#
EventHistory::latest

source
fn EventHistory::latest(self : EventHistory) -> AlertEvent?

#
EventHistory::length

source
fn EventHistory::length(self : EventHistory) -> Int

#
EventHistory::new

source
fn EventHistory::new(capacity? : Int) -> EventHistory

#
EventHistory::push

source
fn EventHistory::push(self : EventHistory, event : AlertEvent) -> Unit

#
EventHistory::total

source
fn EventHistory::total(self : EventHistory) -> Int

#
EventHistory::unsuppressed_count

source
fn EventHistory::unsuppressed_count(self : EventHistory) -> Int

#
EvidenceContribution

source
pub struct EvidenceContribution {
  name : String
  value : Double
  weight : Double
  contribution : Double
}

Structured evidence for explaining why a detector emitted an alert.

#
EvidenceContribution::new

source
fn EvidenceContribution::new(name : String, value : Double, weight? : Double) -> EvidenceContribution

#
EwmaDetector

source
pub struct EwmaDetector {
  baseline : Double
  variance : Double
  alpha : Double
  threshold : Double
  warmup : Int
  count : Int
  index : Int
  initialized : Bool
}

EWMA residual detector. It is useful for low-latency monitoring of a service metric.

#
EwmaDetector::baseline

source
fn EwmaDetector::baseline(self : EwmaDetector) -> Double

#
EwmaDetector::new

source
fn EwmaDetector::new(alpha? : Double, threshold? : Double, warmup? : Int, initial_mean? : Double, initial_variance? : Double) -> EwmaDetector

#
EwmaDetector::reset

source
fn EwmaDetector::reset(self : EwmaDetector) -> Unit

#
EwmaDetector::scale

source
fn EwmaDetector::scale(self : EwmaDetector) -> Double

#
EwmaDetector::update

source
fn EwmaDetector::update(self : EwmaDetector, value : Double) -> DetectionResult

#
FeatureExtractor

source
pub struct FeatureExtractor {
  left : DoubleWindow
  right : DoubleWindow
  threshold : Double
  index : Int
}

#
FeatureExtractor::new

source
fn FeatureExtractor::new(window_size? : Int, threshold? : Double) -> FeatureExtractor

#
FeatureExtractor::update

source
fn FeatureExtractor::update(self : FeatureExtractor, value : Double) -> DetectionResult

#
ForecastPoint

source
pub struct ForecastPoint {
  prediction : Double
  lower : Double
  upper : Double
  residual : Double
}

#
ForecastPoint::new

source
fn ForecastPoint::new(prediction : Double, residual : Double, uncertainty? : Double) -> ForecastPoint

#
Histogram

source
pub struct Histogram {
  minimum : Double
  maximum : Double
  bins : Int
  counts : Array[Int]
  total : Int
}

A fixed-edge histogram for monitoring changes in value distribution.

#
Histogram::bins

source
fn Histogram::bins(self : Histogram) -> Int

#
Histogram::counts

source
fn Histogram::counts(self : Histogram) -> Array[Int]

#
Histogram::new

source
fn Histogram::new(minimum : Double, maximum : Double, bins : Int) -> Histogram

#
Histogram::probabilities

source
fn Histogram::probabilities(self : Histogram) -> Array[Double]

#
Histogram::push

source
fn Histogram::push(self : Histogram, value : Double) -> Unit

#
Histogram::reset

source
fn Histogram::reset(self : Histogram) -> Unit

#
Histogram::total

source
fn Histogram::total(self : Histogram) -> Int

#
HoltForecaster

source
pub struct HoltForecaster {
  level : Double
  trend : Double
  alpha : Double
  beta : Double
  count : Int
}

#
HoltForecaster::new

source
fn HoltForecaster::new(alpha? : Double, beta? : Double) -> HoltForecaster

#
HoltForecaster::update

source
fn HoltForecaster::update(self : HoltForecaster, value : Double, horizon? : Int) -> ForecastPoint

#
HysteresisRule

source
pub struct HysteresisRule {
  enter_threshold : Double
  exit_threshold : Double
  active : Bool
}

Hysteresis prevents alert flapping around a single threshold.

#
HysteresisRule::active

source
fn HysteresisRule::active(self : HysteresisRule) -> Bool

#
HysteresisRule::new

source
fn HysteresisRule::new(enter_threshold? : Double, exit_threshold? : Double) -> HysteresisRule

#
HysteresisRule::push

source
fn HysteresisRule::push(self : HysteresisRule, score : Double) -> Bool

#
Incident

source
pub struct Incident {
  metric : String
  first_timestamp : Int64
  last_timestamp : Int64
  alerts : Int
  critical : Int
  maximum_score : Double
  direction : ChangeDirection
}

Groups nearby alert events into incidents for operators.

#
Incident::add

source
fn Incident::add(self : Incident, event : AlertEvent) -> Unit

#
Incident::duration

source
fn Incident::duration(self : Incident) -> Int64

#
Incident::empty

source
fn Incident::empty(metric : String) -> Incident

#
Incident::is_critical

source
fn Incident::is_critical(self : Incident) -> Bool

#
Incident::summary

source
fn Incident::summary(self : Incident) -> String

#
IqrSpikeDetector

source
pub struct IqrSpikeDetector {
  window : DoubleWindow
  multiplier : Double
  warmup : Int
  index : Int
}

A lightweight detector for isolated spikes using a rolling interquartile fence.

#
IqrSpikeDetector::new

source
fn IqrSpikeDetector::new(window_size? : Int, multiplier? : Double) -> IqrSpikeDetector

#
IqrSpikeDetector::update

source
fn IqrSpikeDetector::update(self : IqrSpikeDetector, value : Double) -> DetectionResult

#
LateDataPolicy

source
pub(all) enum LateDataPolicy {
  Drop
  KeepForCorrection
  ReplaceSameTimestamp
}

The policy applied when a timestamp is older than the accepted watermark.

#
LinearForecaster

source
pub struct LinearForecaster {
  window : DoubleWindow
  horizon : Int
  uncertainty_multiplier : Double
}

#
LinearForecaster::fit

source
fn LinearForecaster::fit(self : LinearForecaster, value : Double) -> ForecastPoint

#
LinearForecaster::new

source
fn LinearForecaster::new(window_size? : Int, horizon? : Int, uncertainty_multiplier? : Double) -> LinearForecaster

#
MahalanobisDetector

source
pub struct MahalanobisDetector {
  stats : OnlineVectorStats
  threshold : Double
  warmup : Int
  index : Int
}

Diagonal Mahalanobis detector. It remains usable when a full covariance matrix is unavailable.

#
MahalanobisDetector::count

source
fn MahalanobisDetector::count(self : MahalanobisDetector) -> Int

#
MahalanobisDetector::dimension

source
fn MahalanobisDetector::dimension(self : MahalanobisDetector) -> Int

#
MahalanobisDetector::new

source
fn MahalanobisDetector::new(dimension : Int, threshold? : Double, warmup? : Int) -> MahalanobisDetector

#
MahalanobisDetector::update

source
fn MahalanobisDetector::update(self : MahalanobisDetector, values : Array[Double]) -> DetectionResult

#
MeanVarianceDetector

source
pub struct MeanVarianceDetector {
  baseline : DoubleWindow
  current : DoubleWindow
  mean_threshold : Double
  variance_threshold : Double
  index : Int
}

#
MeanVarianceDetector::new

source
fn MeanVarianceDetector::new(window_size? : Int, mean_threshold? : Double, variance_threshold? : Double) -> MeanVarianceDetector

#
MeanVarianceDetector::update

source
fn MeanVarianceDetector::update(self : MeanVarianceDetector, value : Double) -> DetectionResult

#
MetricPipeline

source
pub struct MetricPipeline {
  name : String
  detector : PipelineDetector
  policy : AlertPolicy
  index : Int
  ordinal : Int
  baseline : Double
}

One named metric with a detector and an alert policy.

#
MetricPipeline::index

source
fn MetricPipeline::index(self : MetricPipeline) -> Int

#
MetricPipeline::new

source
fn MetricPipeline::new(name : String, detector : PipelineDetector, policy? : AlertPolicy, baseline? : Double) -> MetricPipeline

#
MetricPipeline::process

source
fn MetricPipeline::process(self : MetricPipeline, timestamp : Int64, value : Double) -> AlertEvent?

#
MetricPipeline::reset

source
fn MetricPipeline::reset(self : MetricPipeline) -> Unit

#
MultiMetricMonitor

source
pub struct MultiMetricMonitor {
  pipelines : Array[MetricPipeline]
  processed : Int
  emitted : Int
  suppressed : Int
}

A deterministic multi-metric monitor. It is intentionally array-backed for WASM portability.

#
MultiMetricMonitor::emitted_count

source
fn MultiMetricMonitor::emitted_count(self : MultiMetricMonitor) -> Int

#
MultiMetricMonitor::metric_count

source
fn MultiMetricMonitor::metric_count(self : MultiMetricMonitor) -> Int

#
MultiMetricMonitor::new

source

#
MultiMetricMonitor::process

source
fn MultiMetricMonitor::process(self : MultiMetricMonitor, metric_index : Int, timestamp : Int64, value : Double) -> AlertEvent?

#
MultiMetricMonitor::process_batch

source
fn MultiMetricMonitor::process_batch(self : MultiMetricMonitor, metric_index : Int, points : Array[SignalPoint]) -> Array[AlertEvent]

#
MultiMetricMonitor::processed_count

source
fn MultiMetricMonitor::processed_count(self : MultiMetricMonitor) -> Int

#
MultiMetricMonitor::suppressed_count

source
fn MultiMetricMonitor::suppressed_count(self : MultiMetricMonitor) -> Int

#
MultiScaleDetector

source
pub struct MultiScaleDetector {
  short : RobustZDetector
  medium : RobustZDetector
  long : TrendShiftDetector
  minimum_consensus : Double
  index : Int
}

#
MultiScaleDetector::new

source
fn MultiScaleDetector::new(short? : Int, medium? : Int, long? : Int, minimum_consensus? : Double) -> MultiScaleDetector

#
MultiScaleDetector::update

source
fn MultiScaleDetector::update(self : MultiScaleDetector, value : Double) -> DetectionResult

#
MultivariateEnsemble

source
pub struct MultivariateEnsemble {
  detectors : Array[ProjectionDetector]
  quorum : Int
  index : Int
}

An ensemble that combines several multivariate views with a quorum rule.

#
MultivariateEnsemble::detector_count

source
fn MultivariateEnsemble::detector_count(self : MultivariateEnsemble) -> Int

#
MultivariateEnsemble::new

source
fn MultivariateEnsemble::new(detectors : Array[ProjectionDetector], quorum? : Int) -> MultivariateEnsemble

#
MultivariateEnsemble::update

source
fn MultivariateEnsemble::update(self : MultivariateEnsemble, values : Array[Double]) -> DetectionResult

#
OfflineChange

source
pub struct OfflineChange {
  index : Int
  score : Double
  left_mean : Double
  right_mean : Double
  left_variance : Double
  right_variance : Double
  direction : ChangeDirection
}

A candidate change point returned by offline analysis.

#
OnlineEnsemble

source
pub struct OnlineEnsemble {
  detectors : Array[PipelineDetector]
  quorum : Int
  index : Int
}

#
OnlineEnsemble::count

source
fn OnlineEnsemble::count(self : OnlineEnsemble) -> Int

#
OnlineEnsemble::new

source
fn OnlineEnsemble::new(detectors : Array[PipelineDetector], quorum? : Int) -> OnlineEnsemble

#
OnlineEnsemble::update

source
fn OnlineEnsemble::update(self : OnlineEnsemble, value : Double) -> EnsembleResult

#
OnlineMoments

source
pub struct OnlineMoments {
  count : Int
  mean : Double
  m2 : Double
  minimum : Double
  maximum : Double
}

Numerically stable online moments using Welford's recurrence.

#
OnlineMoments::count

source
fn OnlineMoments::count(self : OnlineMoments) -> Int

#
OnlineMoments::maximum

source
fn OnlineMoments::maximum(self : OnlineMoments) -> Double

#
OnlineMoments::mean

source
fn OnlineMoments::mean(self : OnlineMoments) -> Double

#
OnlineMoments::merge

source
fn OnlineMoments::merge(self : OnlineMoments, other : OnlineMoments) -> Unit

#
OnlineMoments::minimum

source
fn OnlineMoments::minimum(self : OnlineMoments) -> Double

#
OnlineMoments::new

source

Creates an empty accumulator.

#
OnlineMoments::population_variance

source
fn OnlineMoments::population_variance(self : OnlineMoments) -> Double

#
OnlineMoments::push

source
fn OnlineMoments::push(self : OnlineMoments, value : Double) -> Unit

Adds one observation.

#
OnlineMoments::standard_deviation

source
fn OnlineMoments::standard_deviation(self : OnlineMoments) -> Double

#
OnlineMoments::summary

source
fn OnlineMoments::summary(self : OnlineMoments, median? : Double) -> StatsSummary

#
OnlineMoments::variance

source
fn OnlineMoments::variance(self : OnlineMoments) -> Double

#
OnlineMoments::with_prior

source
fn OnlineMoments::with_prior(mean : Double, variance : Double, weight : Int) -> OnlineMoments

Creates an accumulator with a prior mean and effective sample size.

#
OnlineVectorStats

source
pub struct OnlineVectorStats {
  dimension : Int
  count : Int
  means : Array[Double]
  m2 : Array[Double]
  minima : Array[Double]
  maxima : Array[Double]
}

Per-dimension Welford statistics for a vector stream.

#
OnlineVectorStats::count

source
fn OnlineVectorStats::count(self : OnlineVectorStats) -> Int

#
OnlineVectorStats::dimension

source
fn OnlineVectorStats::dimension(self : OnlineVectorStats) -> Int

#
OnlineVectorStats::maximums

source
fn OnlineVectorStats::maximums(self : OnlineVectorStats) -> Array[Double]

#
OnlineVectorStats::means

source
fn OnlineVectorStats::means(self : OnlineVectorStats) -> Array[Double]

#
OnlineVectorStats::minimums

source
fn OnlineVectorStats::minimums(self : OnlineVectorStats) -> Array[Double]

#
OnlineVectorStats::new

source
fn OnlineVectorStats::new(dimension : Int) -> OnlineVectorStats

#
OnlineVectorStats::push

source
fn OnlineVectorStats::push(self : OnlineVectorStats, values : Array[Double]) -> Bool

#
OnlineVectorStats::standard_deviations

source
fn OnlineVectorStats::standard_deviations(self : OnlineVectorStats) -> Array[Double]

#
OnlineVectorStats::standardized

source
fn OnlineVectorStats::standardized(self : OnlineVectorStats, values : Array[Double]) -> Array[Double]

#
OnlineVectorStats::variances

source
fn OnlineVectorStats::variances(self : OnlineVectorStats) -> Array[Double]

#
OrderedPoint

source
pub struct OrderedPoint {
  point : SignalPoint
  late : Bool
  arrival_order : Int
}

A timestamped sample that has passed through a reorder buffer.

#
PageHinkley

source
pub struct PageHinkley {
  target_mean : Double
  control_limit : Double
  delta : Double
  alpha : Double
  sum : Double
  min_sum : Double
  n : Int
}

PageHinkley implements the Page-Hinkley test for online change point detection.

#
PageHinkley::new

source
fn PageHinkley::new(target_mean? : Double, control_limit? : Double, delta? : Double, alpha? : Double) -> PageHinkley

Creates a new Page-Hinkley detector.

#
PageHinkley::reset

source
fn PageHinkley::reset(self : PageHinkley) -> Unit

Resets the internal accumulators.

#
PageHinkley::update

source
fn PageHinkley::update(self : PageHinkley, value : Double) -> Bool

Updates the Page-Hinkley detector with a new value and returns true if a change is detected.

#
PageHinkley::update_result

source
fn PageHinkley::update_result(self : PageHinkley, value : Double, index? : Int) -> DetectionResult

Rich result form of update, retaining direction and cumulative evidence.

#
PersistenceDetector

source
pub struct PersistenceDetector {
  detector : EwmaDetector
  rule : ConsecutiveRule
  index : Int
}

#
PersistenceDetector::new

source
fn PersistenceDetector::new(warmup? : Int, persistence? : Int) -> PersistenceDetector

#
PersistenceDetector::update

source
fn PersistenceDetector::update(self : PersistenceDetector, value : Double) -> DetectionResult

#
PipelineDetector

source
pub(all) enum PipelineDetector {
  LegacyDetector(Detector)
  Ewma(EwmaDetector)
  RobustZ(RobustZDetector)
  VarianceShift(VarianceShiftDetector)
  TrendShift(TrendShiftDetector)
  IqrSpike(IqrSpikeDetector)
}

A detector that can be selected for a production metric pipeline.

#
PipelineDetector::update

source
fn PipelineDetector::update(self : PipelineDetector, value : Double, index : Int) -> DetectionResult

#
ProjectionDetector

source
pub struct ProjectionDetector {
  weights : Array[Double]
  baseline : Double
  variance : Double
  alpha : Double
  threshold : Double
  count : Int
  index : Int
}

Tracks a weighted projection of a vector and detects changes in both projection and energy.

#
ProjectionDetector::dimension

source
fn ProjectionDetector::dimension(self : ProjectionDetector) -> Int

#
ProjectionDetector::new

source
fn ProjectionDetector::new(weights : Array[Double], alpha? : Double, threshold? : Double) -> ProjectionDetector

#
ProjectionDetector::update

source
fn ProjectionDetector::update(self : ProjectionDetector, values : Array[Double]) -> DetectionResult

#
QualityIssue

source
pub(all) enum QualityIssue {
  MissingValue
  NonFiniteValue
  OutOfRange
  NonMonotonicTimestamp
  ExcessiveGap
  DimensionMismatch
}

#
QualityReport

source
pub struct QualityReport {
  count : Int
  valid : Int
  missing : Int
  non_finite : Int
  out_of_range : Int
  non_monotonic : Int
  excessive_gaps : Int
  issues : Array[QualityIssue]
}

#
QualityReport::empty

source

#
QualityReport::is_healthy

source
fn QualityReport::is_healthy(self : QualityReport) -> Bool

#
QualityReport::valid_ratio

source
fn QualityReport::valid_ratio(self : QualityReport) -> Double

#
RankShiftDetector

source
pub struct RankShiftDetector {
  left : DoubleWindow
  right : DoubleWindow
  threshold : Double
  index : Int
}

#
RankShiftDetector::new

source
fn RankShiftDetector::new(window_size? : Int, threshold? : Double) -> RankShiftDetector

#
RankShiftDetector::update

source
fn RankShiftDetector::update(self : RankShiftDetector, value : Double) -> DetectionResult

#
RecoveryPlan

source
pub struct RecoveryPlan {
  severity : AlertSeverity
  immediate_action : String
  verification_window : Int
  cooldown : Int
  escalation_score : Double
}

Recovery guidance and cooldown state for alert consumers.

#
RecoveryPlan::for_result

source
fn RecoveryPlan::for_result(result : DetectionResult) -> RecoveryPlan

#
RecoveryTracker

source
pub struct RecoveryTracker {
  plan : RecoveryPlan
  attempts : Int
  acknowledged : Bool
  recovered : Bool
}

#
RecoveryTracker::acknowledge

source
fn RecoveryTracker::acknowledge(self : RecoveryTracker) -> Unit

#
RecoveryTracker::attempt

source
fn RecoveryTracker::attempt(self : RecoveryTracker) -> Int

#
RecoveryTracker::attempts

source
fn RecoveryTracker::attempts(self : RecoveryTracker) -> Int

#
RecoveryTracker::is_closed

source
fn RecoveryTracker::is_closed(self : RecoveryTracker) -> Bool

#
RecoveryTracker::mark_recovered

source
fn RecoveryTracker::mark_recovered(self : RecoveryTracker) -> Unit

#
RecoveryTracker::new

source

#
ReorderBuffer

source
pub struct ReorderBuffer {
  capacity : Int
  policy : LateDataPolicy
  pending : Array[OrderedPoint]
  watermark : Int64
  arrival_order : Int
  dropped : Int
  late_count : Int
}

A small bounded reorder buffer for streams with late data.

#
ReorderBuffer::dropped_count

source
fn ReorderBuffer::dropped_count(self : ReorderBuffer) -> Int

#
ReorderBuffer::flush

source

Flushes every pending item at the end of a stream.

#
ReorderBuffer::late_count

source
fn ReorderBuffer::late_count(self : ReorderBuffer) -> Int

#
ReorderBuffer::new

source
fn ReorderBuffer::new(capacity? : Int, policy? : LateDataPolicy) -> ReorderBuffer

#
ReorderBuffer::peek

source

Returns a copy of the buffered points without changing the buffer.

#
ReorderBuffer::pending_count

source
fn ReorderBuffer::pending_count(self : ReorderBuffer) -> Int

#
ReorderBuffer::push

source

Inserts a point. Returned points are safe to process in timestamp order.

#
ReorderBuffer::watermark

source
fn ReorderBuffer::watermark(self : ReorderBuffer) -> Int64

#
ReplayComparator

source
pub struct ReplayComparator {
  score_tolerance : Double
  confidence_tolerance : Double
  compared : Int
  mismatches : Int
}

#
ReplayComparator::compare

source
fn ReplayComparator::compare(self : ReplayComparator, expected : DetectionResult, actual : DetectionResult) -> Bool

#
ReplayComparator::compared

source
fn ReplayComparator::compared(self : ReplayComparator) -> Int

#
ReplayComparator::mismatches

source
fn ReplayComparator::mismatches(self : ReplayComparator) -> Int

#
ReplayComparator::new

source
fn ReplayComparator::new(score_tolerance? : Double, confidence_tolerance? : Double) -> ReplayComparator

#
ReplayRecord

source
pub struct ReplayRecord {
  point : SignalPoint
  result : DetectionResult
  elapsed : Int64
}

Deterministic replay utilities for incident investigation and regression tests.

#
ReplayRecord::new

source
fn ReplayRecord::new(point : SignalPoint, result : DetectionResult, elapsed : Int64) -> ReplayRecord

#
ReplaySummary

source
pub struct ReplaySummary {
  total : Int
  changed : Int
  first_change : Int
  last_change : Int
  mean_score : Double
  max_score : Double
  elapsed : Int64
}

#
ReplaySummary::empty

source

#
ReservoirSample

source
pub struct ReservoirSample {
  capacity : Int
  values : Array[Double]
  seen : Int
  rng : DeterministicRng
}

#
ReservoirSample::new

source
fn ReservoirSample::new(capacity : Int, seed? : Int64) -> ReservoirSample

#
ReservoirSample::push

source
fn ReservoirSample::push(self : ReservoirSample, value : Double) -> Unit

#
ReservoirSample::seen

source
fn ReservoirSample::seen(self : ReservoirSample) -> Int

#
ReservoirSample::values

source
fn ReservoirSample::values(self : ReservoirSample) -> Array[Double]

#
RobustZDetector

source
pub struct RobustZDetector {
  window : DoubleWindow
  threshold : Double
  warmup : Int
  index : Int
}

A robust detector based on the rolling median and MAD.

#
RobustZDetector::new

source
fn RobustZDetector::new(window_size? : Int, threshold? : Double) -> RobustZDetector

#
RobustZDetector::reset

source
fn RobustZDetector::reset(self : RobustZDetector) -> Unit

#
RobustZDetector::update

source
fn RobustZDetector::update(self : RobustZDetector, value : Double) -> DetectionResult

#
RoutingBudget

source
pub struct RoutingBudget {
  capacity : Int
  used : Int
}

#
RoutingBudget::allow

source
fn RoutingBudget::allow(self : RoutingBudget, decision : RoutingDecision) -> Bool

#
RoutingBudget::new

source
fn RoutingBudget::new(capacity? : Int) -> RoutingBudget

#
RoutingBudget::remaining

source
fn RoutingBudget::remaining(self : RoutingBudget) -> Int

#
RoutingBudget::used

source
fn RoutingBudget::used(self : RoutingBudget) -> Int

#
RoutingDecision

source
pub struct RoutingDecision {
  metric : String
  channel : String
  priority : Int
  acknowledged : Bool
  reason : String
}

Converts alert severity into deterministic notification channels.

#
RoutingDecision::acknowledge

source
fn RoutingDecision::acknowledge(self : RoutingDecision) -> Unit

#
RoutingDecision::is_page

source
fn RoutingDecision::is_page(self : RoutingDecision) -> Bool

#
RoutingDecision::new

source
fn RoutingDecision::new(metric : String, channel : String, priority : Int, reason : String) -> RoutingDecision

#
RoutingDecision::summary

source
fn RoutingDecision::summary(self : RoutingDecision) -> String

#
ScaleEvidence

source
pub struct ScaleEvidence {
  short_score : Double
  medium_score : Double
  long_score : Double
  consensus : Double
  changed : Bool
}

Evidence at multiple temporal scales.

#
ScaleEvidence::empty

source

#
ScoreCalibrator

source
pub struct ScoreCalibrator {
  observations : Array[ScoreObservation]
  max_observations : Int
  positive_weight : Double
  negative_weight : Double
}

#
ScoreCalibrator::best

source
fn ScoreCalibrator::best(self : ScoreCalibrator, candidates : Array[Double]) -> ThresholdReport

#
ScoreCalibrator::count

source
fn ScoreCalibrator::count(self : ScoreCalibrator) -> Int

#
ScoreCalibrator::negative_weight

source
fn ScoreCalibrator::negative_weight(self : ScoreCalibrator) -> Double

#
ScoreCalibrator::new

source
fn ScoreCalibrator::new(max_observations? : Int) -> ScoreCalibrator

#
ScoreCalibrator::positive_weight

source
fn ScoreCalibrator::positive_weight(self : ScoreCalibrator) -> Double

#
ScoreCalibrator::push

source
fn ScoreCalibrator::push(self : ScoreCalibrator, score : Double, changed : Bool, weight? : Double) -> Unit

#
ScoreCalibrator::report

source
fn ScoreCalibrator::report(self : ScoreCalibrator, threshold : Double) -> ThresholdReport

#
ScoreObservation

source
pub struct ScoreObservation {
  score : Double
  changed : Bool
  weight : Double
}

Stores labeled detector scores for threshold selection.

#
ScoreObservation::new

source
fn ScoreObservation::new(score : Double, changed : Bool, weight? : Double) -> ScoreObservation

#
SeasonalAnomalyDetector

source
pub struct SeasonalAnomalyDetector {
  profile : SeasonalProfile
  threshold : Double
  index : Int
}

#
SeasonalAnomalyDetector::new

source
fn SeasonalAnomalyDetector::new(period : Int, threshold? : Double, alpha? : Double) -> SeasonalAnomalyDetector

#
SeasonalAnomalyDetector::update

source

#
SeasonalProfile

source
pub struct SeasonalProfile {
  period : Int
  levels : Array[Double]
  counts : Array[Int]
  alpha : Double
  index : Int
}

A lightweight seasonal profile updated online with exponential forgetting.

#
SeasonalProfile::baseline

source
fn SeasonalProfile::baseline(self : SeasonalProfile, index : Int) -> Double

#
SeasonalProfile::count

source
fn SeasonalProfile::count(self : SeasonalProfile, index : Int) -> Int

#
SeasonalProfile::levels

source
fn SeasonalProfile::levels(self : SeasonalProfile) -> Array[Double]

#
SeasonalProfile::new

source
fn SeasonalProfile::new(period : Int, alpha? : Double) -> SeasonalProfile

#
SeasonalProfile::period

source
fn SeasonalProfile::period(self : SeasonalProfile) -> Int

#
SeasonalProfile::update

source
fn SeasonalProfile::update(self : SeasonalProfile, value : Double) -> Double

#
SegmentQuality

source
pub struct SegmentQuality {
  count : Int
  mean : Double
  deviation : Double
  stability : Double
  completeness : Double
  score : Double
}

Segment-level diagnostics used to decide whether a change is actionable.

#
SegmentQuality::empty

source

#
SegmentRange

source
pub struct SegmentRange {
  start : Int
  end : Int
}

A half-open segment used by dynamic programming and binary segmentation.

#
SegmentRange::length

source
fn SegmentRange::length(self : SegmentRange) -> Int

#
SegmentRange::new

source
fn SegmentRange::new(start : Int, end : Int) -> SegmentRange

#
SignalPattern

source
pub(all) enum SignalPattern {
  Stable
  MeanShift
  VarianceShift
  Trend
  Spike
  MeanAndVarianceShift
}

#
SignalPoint

source
pub struct SignalPoint {
  timestamp : Int64
  value : Double
  sequence : Int
}

A point in a time series. Timestamps are integer ticks supplied by the caller.

#
SignalPoint::new

source
fn SignalPoint::new(timestamp : Int64, value : Double, sequence? : Int) -> SignalPoint

Creates a signal point.

#
SignalScenario

source
pub struct SignalScenario {
  name : String
  length : Int
  change_at : Int
  baseline : Double
  shift : Double
  noise : Double
  post_noise : Double
  trend : Double
  pattern : SignalPattern
  seed : Int64
}

A scenario definition shared by tests, examples, and benchmarks.

#
SignalScenario::mean_and_variance

source
fn SignalScenario::mean_and_variance(length? : Int, change_at? : Int, baseline? : Double, shift? : Double, noise? : Double, post_noise? : Double, seed? : Int64) -> SignalScenario

#
SignalScenario::mean_shift

source
fn SignalScenario::mean_shift(length? : Int, change_at? : Int, baseline? : Double, shift? : Double, noise? : Double, seed? : Int64) -> SignalScenario

#
SignalScenario::spike

source
fn SignalScenario::spike(length? : Int, spike_at? : Int, baseline? : Double, spike? : Double, noise? : Double, seed? : Int64) -> SignalScenario

#
SignalScenario::stable

source
fn SignalScenario::stable(length? : Int, baseline? : Double, noise? : Double, seed? : Int64) -> SignalScenario

#
SignalScenario::trend

source
fn SignalScenario::trend(length? : Int, change_at? : Int, baseline? : Double, trend? : Double, noise? : Double, seed? : Int64) -> SignalScenario

#
SignalScenario::variance_shift

source
fn SignalScenario::variance_shift(length? : Int, change_at? : Int, baseline? : Double, noise? : Double, post_noise? : Double, seed? : Int64) -> SignalScenario

#
SloReport

source
pub struct SloReport {
  window : SloWindow
  target : Double
  budget : Double
  burn : Double
  breached : Bool
  recommendation : String
}

#
SloReport::availability

source
fn SloReport::availability(self : SloReport) -> Double

#
SloReport::breached

source
fn SloReport::breached(self : SloReport) -> Bool

#
SloReport::budget

source
fn SloReport::budget(self : SloReport) -> Double

#
SloReport::burn

source
fn SloReport::burn(self : SloReport) -> Double

#
SloReport::summary

source
fn SloReport::summary(self : SloReport) -> String

#
SloTracker

source
pub struct SloTracker {
  window : SloWindow
  target : Double
  burn_limit : Double
  periods : Int
}

#
SloTracker::close_period

source
fn SloTracker::close_period(self : SloTracker) -> SloReport

#
SloTracker::new

source
fn SloTracker::new(target? : Double, burn_limit? : Double) -> SloTracker

#
SloTracker::observe

source
fn SloTracker::observe(self : SloTracker, result : DetectionResult) -> Unit

#
SloTracker::periods

source
fn SloTracker::periods(self : SloTracker) -> Int

#
SloTracker::window

source
fn SloTracker::window(self : SloTracker) -> SloWindow

#
SloWindow

source
pub struct SloWindow {
  total : Int
  bad : Int
  changed : Int
  severe : Int
}

Service-level indicators derived from change-point evidence.

#
SloWindow::availability

source
fn SloWindow::availability(self : SloWindow) -> Double

#
SloWindow::bad

source
fn SloWindow::bad(self : SloWindow) -> Int

#
SloWindow::change_rate

source
fn SloWindow::change_rate(self : SloWindow) -> Double

#
SloWindow::changed

source
fn SloWindow::changed(self : SloWindow) -> Int

#
SloWindow::new

source
fn SloWindow::new() -> SloWindow

#
SloWindow::observe

source
fn SloWindow::observe(self : SloWindow, result : DetectionResult) -> Unit

#
SloWindow::severe

source
fn SloWindow::severe(self : SloWindow) -> Int

#
SloWindow::total

source
fn SloWindow::total(self : SloWindow) -> Int

#
SquareMatrix

source
pub struct SquareMatrix {
  size : Int
  data : Array[Double]
}

Small dense matrix type used for low-dimensional covariance diagnostics.

#
SquareMatrix::add

source

#
SquareMatrix::determinant

source
fn SquareMatrix::determinant(self : SquareMatrix) -> Double

#
SquareMatrix::diagonal

source
fn SquareMatrix::diagonal(self : SquareMatrix) -> Array[Double]

#
SquareMatrix::get

source
fn SquareMatrix::get(self : SquareMatrix, row : Int, column : Int) -> Double

#
SquareMatrix::identity

source
fn SquareMatrix::identity(size : Int) -> SquareMatrix

#
SquareMatrix::multiply

source
fn SquareMatrix::multiply(self : SquareMatrix, other : SquareMatrix) -> SquareMatrix

#
SquareMatrix::new

source
fn SquareMatrix::new(size : Int, fill? : Double) -> SquareMatrix

#
SquareMatrix::quadratic_form

source
fn SquareMatrix::quadratic_form(self : SquareMatrix, vector : Array[Double]) -> Double

#
SquareMatrix::regularize

source
fn SquareMatrix::regularize(self : SquareMatrix, diagonal : Double) -> Unit

#
SquareMatrix::scale

source
fn SquareMatrix::scale(self : SquareMatrix, factor : Double) -> SquareMatrix

#
SquareMatrix::set

source
fn SquareMatrix::set(self : SquareMatrix, row : Int, column : Int, value : Double) -> Unit

#
SquareMatrix::size

source
fn SquareMatrix::size(self : SquareMatrix) -> Int

#
SquareMatrix::transpose

source
fn SquareMatrix::transpose(self : SquareMatrix) -> SquareMatrix

#
StatsSummary

source
pub struct StatsSummary {
  count : Int
  mean : Double
  variance : Double
  standard_deviation : Double
  minimum : Double
  maximum : Double
  median : Double
  first : Double
  last : Double
}

A compact summary of a numeric sample.

#
StatsSummary::empty

source
fn StatsSummary::empty() -> StatsSummary

Creates an empty summary.

#
StepChangeDetector

source
pub struct StepChangeDetector {
  reference : DoubleWindow
  current : DoubleWindow
  threshold : Double
  index : Int
}

Detects a persistent step change by comparing a reference and a current block.

#
StepChangeDetector::new

source
fn StepChangeDetector::new(window_size? : Int, threshold? : Double) -> StepChangeDetector

#
StepChangeDetector::update

source
fn StepChangeDetector::update(self : StepChangeDetector, value : Double) -> DetectionResult

#
StreamEngine

source
pub struct StreamEngine {
  reorder : ReorderBuffer
  tracker : WatermarkTracker
  aggregator : WindowAggregator
  pipeline : MetricPipeline
  processed : Int
  aggregates : Int
  alerts : Int
}

End-to-end stream state: reorder, aggregate, and detect.

#
StreamEngine::aggregate_count

source
fn StreamEngine::aggregate_count(self : StreamEngine) -> Int

#
StreamEngine::alert_count

source
fn StreamEngine::alert_count(self : StreamEngine) -> Int

#
StreamEngine::flush

source

#
StreamEngine::new

source
fn StreamEngine::new(metric : String, detector : PipelineDetector, window_size? : Int, lateness? : Int) -> StreamEngine

#
StreamEngine::process_point

source
fn StreamEngine::process_point(self : StreamEngine, point : SignalPoint) -> Array[AlertEvent]

#
StreamEngine::processed

source
fn StreamEngine::processed(self : StreamEngine) -> Int

#
ThresholdPoint

source
pub struct ThresholdPoint {
  index : Int
  threshold : Double
  score : Double
  accepted : Bool
}

Threshold schedules used when a service changes its noise profile over time.

#
ThresholdPoint::new

source
fn ThresholdPoint::new(index : Int, score : Double, threshold : Double) -> ThresholdPoint

#
ThresholdReport

source
pub struct ThresholdReport {
  threshold : Double
  true_positives : Int
  false_positives : Int
  true_negatives : Int
  false_negatives : Int
  precision : Double
  recall : Double
  f1 : Double
  expected_cost : Double
}

#
ThresholdReport::empty

source
fn ThresholdReport::empty(threshold : Double) -> ThresholdReport

#
TimeWindow

source
pub struct TimeWindow {
  start : Int64
  end : Int64
  ordinal : Int
}

Time-window planning utilities for batch and streaming consumers.

#
TimeWindow::contains

source
fn TimeWindow::contains(self : TimeWindow, timestamp : Int64) -> Bool

#
TimeWindow::duration

source
fn TimeWindow::duration(self : TimeWindow) -> Int64

#
TimeWindow::is_empty

source
fn TimeWindow::is_empty(self : TimeWindow) -> Bool

#
TimeWindow::new

source
fn TimeWindow::new(start : Int64, end : Int64, ordinal : Int) -> TimeWindow

#
TrendShiftDetector

source
pub struct TrendShiftDetector {
  window : DoubleWindow
  slope_threshold : Double
  persistence : Int
  consecutive : Int
  index : Int
}

Detects a sustained slope rather than a one-point spike.

#
TrendShiftDetector::new

source
fn TrendShiftDetector::new(window_size? : Int, slope_threshold? : Double, persistence? : Int) -> TrendShiftDetector

#
TrendShiftDetector::reset

source
fn TrendShiftDetector::reset(self : TrendShiftDetector) -> Unit

#
TrendShiftDetector::update

source
fn TrendShiftDetector::update(self : TrendShiftDetector, value : Double) -> DetectionResult

#
VarianceShiftDetector

source
pub struct VarianceShiftDetector {
  short_window : DoubleWindow
  long_window : DoubleWindow
  threshold : Double
  warmup : Int
  index : Int
}

Detects variance changes by comparing short and long rolling windows.

#
VarianceShiftDetector::new

source
fn VarianceShiftDetector::new(short_window? : Int, long_window? : Int, threshold? : Double) -> VarianceShiftDetector

#
VarianceShiftDetector::reset

source

#
VarianceShiftDetector::update

source
fn VarianceShiftDetector::update(self : VarianceShiftDetector, value : Double) -> DetectionResult

#
VectorPoint

source
pub struct VectorPoint {
  timestamp : Int64
  values : Array[Double]
  sequence : Int
}

A validated vector observation for multivariate streams.

#
VectorPoint::dimension

source
fn VectorPoint::dimension(self : VectorPoint) -> Int

#
VectorPoint::is_valid

source
fn VectorPoint::is_valid(self : VectorPoint) -> Bool

#
VectorPoint::new

source
fn VectorPoint::new(timestamp : Int64, values : Array[Double], sequence? : Int) -> VectorPoint

#
VoteRule

source
pub struct VoteRule {
  required : Int
  window : Array[Bool]
  size : Int
}

#
VoteRule::new

source
fn VoteRule::new(size? : Int, required? : Int) -> VoteRule

#
VoteRule::push

source
fn VoteRule::push(self : VoteRule, positive : Bool) -> Bool

#
VoteRule::votes

source
fn VoteRule::votes(self : VoteRule) -> Int

#
WatermarkTracker

source
pub struct WatermarkTracker {
  allowed_lateness : Int64
  maximum_seen : Int64
  accepted : Int
  dropped : Int
}

#
WatermarkTracker::accepted

source
fn WatermarkTracker::accepted(self : WatermarkTracker) -> Int

#
WatermarkTracker::dropped

source
fn WatermarkTracker::dropped(self : WatermarkTracker) -> Int

#
WatermarkTracker::new

source
fn WatermarkTracker::new(allowed_lateness? : Int64) -> WatermarkTracker

#
WatermarkTracker::observe

source
fn WatermarkTracker::observe(self : WatermarkTracker, timestamp : Int64) -> Bool

#
WatermarkTracker::watermark

source
fn WatermarkTracker::watermark(self : WatermarkTracker) -> Int64

#
WindowAggregate

source
pub struct WindowAggregate {
  start_timestamp : Int64
  end_timestamp : Int64
  count : Int
  value : Double
  summary : StatsSummary
}

#
WindowAggregator

source
pub struct WindowAggregator {
  size : Int
  kind : AggregationKind
  window : DoubleWindow
  start_timestamp : Int64
  end_timestamp : Int64
  count : Int
}

#
WindowAggregator::flush

source

#
WindowAggregator::new

source
fn WindowAggregator::new(size : Int, kind? : AggregationKind) -> WindowAggregator

#
WindowAggregator::push

source

#
WindowDiagnostic

source
pub struct WindowDiagnostic {
  before : StatsSummary
  after : StatsSummary
  mean_shift : Double
  variance_ratio : Double
  distribution_shift : Double
  severity : AlertSeverity
  actionable : Bool
}

Diagnostic comparison between two adjacent windows.

#
WindowDiagnostic::empty

source

#
WindowFeatures

source
pub struct WindowFeatures {
  count : Int
  mean : Double
  standard_deviation : Double
  median : Double
  mad : Double
  minimum : Double
  maximum : Double
  range : Double
  slope : Double
  autocorrelation : Double
  change_rate : Double
}

Features extracted from a bounded window for dashboards and model input.

#
WindowFeatures::empty

source

#
absolute

source
fn absolute(value : Double) -> Double

Returns the absolute value without exposing math implementation details.

#
absolute_change

source
fn absolute_change(baseline : Double, observed : Double) -> Double

#
actionable_diagnostics

source
fn actionable_diagnostics(diagnostics : Array[WindowDiagnostic]) -> Int

#
adaptive_threshold

source
fn adaptive_threshold(scores : Array[Double], false_positive_rate? : Double) -> Double

#
alerts_markdown

source
fn alerts_markdown(alerts : Array[AlertEvent]) -> String

#
align_by_timestamp

source
fn align_by_timestamp(left : Array[SignalPoint], right : Array[SignalPoint]) -> (Array[Double], Array[Double])

#
array_maximum

source
fn array_maximum(values : Array[Double]) -> Double

#
array_minimum

source
fn array_minimum(values : Array[Double]) -> Double

#
autocorrelation

source
fn autocorrelation(values : Array[Double], lag : Int) -> Double

#
average_pairwise_correlation

source
fn average_pairwise_correlation(series : Array[Array[Double]]) -> Double

#
benchmark_cusum

source
fn benchmark_cusum(scenario : SignalScenario, rounds? : Int) -> BenchmarkResult

#
benchmark_ensemble

source
fn benchmark_ensemble(scenario : SignalScenario, rounds? : Int) -> BenchmarkResult

#
benchmark_markdown

source
fn benchmark_markdown(results : Array[BenchmarkResult]) -> String

#
benchmark_robust_z

source
fn benchmark_robust_z(scenario : SignalScenario, rounds? : Int) -> BenchmarkResult

#
benchmark_suite

source
fn benchmark_suite(rounds? : Int) -> Array[BenchmarkResult]

Runs the standard acceptance benchmark suite on a fixed synthetic scenario.

#
best_boundary

source
fn best_boundary(values : Array[Double], minimum_segment? : Int) -> Int

#
best_f1_threshold

source
fn best_f1_threshold(scores : Array[Double], labels : Array[Bool], candidates : Array[Double]) -> ThresholdPoint

#
best_lag

source
fn best_lag(left : Array[Double], right : Array[Double], maximum_lag : Int) -> Int

#
best_threshold

source
fn best_threshold(observations : Array[ScoreObservation], candidates : Array[Double], false_positive_cost? : Double, false_negative_cost? : Double) -> ThresholdReport

#
binary_segmentation

source
fn binary_segmentation(values : Array[Double], threshold? : Double, min_segment? : Int, max_changes? : Int) -> Array[OfflineChange]

Greedy binary segmentation for a small number of interpretable changes.

#
bootstrap_change_score

source
fn bootstrap_change_score(left : Array[Double], right : Array[Double], replicates? : Int, seed? : Int64) -> BootstrapEstimate

#
bootstrap_mean

source
fn bootstrap_mean(values : Array[Double], replicates? : Int, seed? : Int64) -> BootstrapEstimate

#
boundary_quality

source
fn boundary_quality(values : Array[Double], boundary : Int, minimum_segment? : Int) -> Double

#
bucket_timestamp

source
fn bucket_timestamp(timestamp : Int64, origin : Int64, width : Int64) -> Int64

#
burn_rate

source
fn burn_rate(window : SloWindow, target : Double) -> Double

#
calibration_bins

source
fn calibration_bins(observations : Array[ScoreObservation], bins? : Int) -> Array[Double]

#
catalog_markdown

source
fn catalog_markdown() -> String

#
change_direction_from_values

source
fn change_direction_from_values(baseline : Double, observed : Double) -> ChangeDirection

#
change_point_csv

source
fn change_point_csv(point : ChangePoint) -> String

#
change_point_csv_header

source
fn change_point_csv_header() -> String

#
changes_csv

source
fn changes_csv(points : Array[ChangePoint]) -> String

#
clamp_probability

source
fn clamp_probability(value : Double) -> Double

Clamps a probability-like number to the closed unit interval.

#
clip

source
fn clip(values : Array[Double], lower : Double, upper : Double) -> Array[Double]

#
clip_values

source
fn clip_values(values : Array[Double], minimum : Double, maximum : Double) -> Array[Double]

#
cluster_incidents

source
fn cluster_incidents(events : Array[AlertEvent], maximum_gap : Int64) -> Array[Incident]

#
combine_scores

source
fn combine_scores(scores : Array[Double], weights : Array[Double]) -> Double

#
compare_segment_quality

source
fn compare_segment_quality(left : Array[Double], right : Array[Double]) -> Double

#
consensus_score

source
fn consensus_score(results : Array[DetectionResult]) -> Double

#
contiguous_ranges

source
fn contiguous_ranges(points : Array[SignalPoint], maximum_gap : Int64) -> Array[SegmentRange]

#
cooldown_schedule

source
fn cooldown_schedule(plan : RecoveryPlan, attempts : Int) -> Array[Int]

#
correlated_change_score

source
fn correlated_change_score(before : Array[Array[Double]], after : Array[Array[Double]]) -> Double

#
correlation

source
fn correlation(left : Array[Double], right : Array[Double]) -> Double

#
correlation_alert

source
fn correlation_alert(before : Array[Array[Double]], after : Array[Array[Double]], threshold? : Double) -> DetectionResult

#
correlation_matrix

source
fn correlation_matrix(series : Array[Array[Double]]) -> SquareMatrix

#
cosine_similarity

source
fn cosine_similarity(left : Array[Double], right : Array[Double]) -> Double

#
covariance

source
fn covariance(left : Array[Double], right : Array[Double]) -> Double

#
covariance_matrix

source
fn covariance_matrix(series : Array[Array[Double]]) -> SquareMatrix

#
critical_incident_count

source
fn critical_incident_count(incidents : Array[Incident]) -> Int

#
cumulative_sum

source
fn cumulative_sum(values : Array[Double], initial? : Double) -> Array[Double]

#
cumulative_total

source
fn cumulative_total(values : Array[Double]) -> Array[Double]

#
deduplicate_events

source
fn deduplicate_events(events : Array[AlertEvent], minimum_gap : Int64) -> Array[AlertEvent]

#
deseasonalize

source
fn deseasonalize(values : Array[Double], period : Int) -> Array[Double]

#
detection_csv

source
fn detection_csv(result : DetectionResult) -> String

Converts a detection result to a stable CSV row.

#
detection_csv_header

source
fn detection_csv_header() -> String

#
detector_catalog

source
fn detector_catalog() -> Array[DetectorSpec]

#
detector_names

source
fn detector_names() -> Array[String]

#
detector_reliability

source
fn detector_reliability(results : Array[DetectionResult]) -> Double

#
diagnose_series

source
fn diagnose_series(values : Array[Double], split : Int, minimum_segment? : Int) -> WindowDiagnostic

#
diagnose_windows

source
fn diagnose_windows(before_values : Array[Double], after_values : Array[Double], shift_threshold? : Double, distribution_threshold? : Double) -> WindowDiagnostic

#
diagnostic_direction

source
fn diagnostic_direction(diagnostic : WindowDiagnostic) -> ChangeDirection

#
diagnostic_label

source
fn diagnostic_label(diagnostic : WindowDiagnostic) -> String

#
diagnostic_markdown

source
fn diagnostic_markdown(diagnostic : WindowDiagnostic) -> String

#
diagnostic_score

source
fn diagnostic_score(diagnostic : WindowDiagnostic) -> Double

#
diagnostics_batch

source
fn diagnostics_batch(values : Array[Double], splits : Array[Int]) -> Array[WindowDiagnostic]

#
diagonal_mahalanobis

source
fn diagonal_mahalanobis(vector : Array[Double], means : Array[Double], variances : Array[Double]) -> Double

#
difference

source
fn difference(values : Array[Double], lag? : Int) -> Array[Double]

#
direction_name

source
fn direction_name(direction : ChangeDirection) -> String

Returns a human-readable direction label.

#
distribution_change_score

source
fn distribution_change_score(left : Array[Double], right : Array[Double]) -> Double

#
distribution_overlap

source
fn distribution_overlap(left : Array[Double], right : Array[Double], bins? : Int) -> Double

#
downsample_mean

source
fn downsample_mean(values : Array[Double], factor : Int) -> Array[Double]

#
energy_distance

source
fn energy_distance(left : Array[Double], right : Array[Double]) -> Double

#
error_budget

source
fn error_budget(availability : Double, target : Double) -> Double

#
euclidean_distance

source
fn euclidean_distance(left : Array[Double], right : Array[Double]) -> Double

#
evaluate_change_points

source
fn evaluate_change_points(predicted : Array[Int], truth : Array[Int], tolerance? : Int) -> ChangePointMetrics

Matches a prediction to at most one truth within a tolerance window.

#
evaluate_slo

source
fn evaluate_slo(window : SloWindow, target? : Double, burn_limit? : Double) -> SloReport

#
evaluate_threshold

source
fn evaluate_threshold(observations : Array[ScoreObservation], threshold : Double, false_positive_cost? : Double, false_negative_cost? : Double) -> ThresholdReport

#
event_rate

source
fn event_rate(events : Array[AlertEvent], start : Int64, end : Int64) -> Double

#
evidence_strength

source
fn evidence_strength(score : Double, confidence : Double, deviation : Double) -> Double

#
expected_alert_cost

source
fn expected_alert_cost(false_positive_rate : Double, false_negative_rate : Double, false_positive_cost? : Double, false_negative_cost? : Double) -> Double

#
explain_batch

source
fn explain_batch(results : Array[DetectionResult], baseline : Double, values : Array[Double], detector : String) -> Array[DetectionExplanation]

#
explanation_alerts

source
fn explanation_alerts(explanations : Array[DetectionExplanation]) -> Int

#
explanation_csv

source
fn explanation_csv(explanation : DetectionExplanation) -> String

#
explanation_csv_header

source
fn explanation_csv_header() -> String

#
explanation_markdown

source
fn explanation_markdown(explanation : DetectionExplanation) -> String

#
explanation_strength

source
fn explanation_strength(explanation : DetectionExplanation) -> Double

#
exponential_smooth

source
fn exponential_smooth(values : Array[Double], alpha? : Double) -> Array[Double]

#
extract_features

source
fn extract_features(values : Array[Double]) -> WindowFeatures

#
feature_change_score

source
fn feature_change_score(left : Array[Double], right : Array[Double]) -> Double

#
feature_distance

source
fn feature_distance(left : WindowFeatures, right : WindowFeatures) -> Double

#
feature_names

source
fn feature_names() -> Array[String]

#
find_detector

source
fn find_detector(name : String) -> DetectorSpec?

#
first_difference

source
fn first_difference(values : Array[Double]) -> Array[Double]

#
forecast_mae

source
fn forecast_mae(actual : Array[Double], predicted : Array[Double]) -> Double

#
forecast_mape

source
fn forecast_mape(actual : Array[Double], predicted : Array[Double]) -> Double

#
forecast_rmse

source
fn forecast_rmse(actual : Array[Double], predicted : Array[Double]) -> Double

#
forward_fill

source
fn forward_fill(values : Array[Double], fallback? : Double) -> Array[Double]

#
generate_signal

source
fn generate_signal(scenario : SignalScenario) -> Array[Double]

Generates a deterministic signal and its known change indices.

#
hampel_filter

source
fn hampel_filter(values : Array[Double], window_size? : Int, threshold? : Double) -> Array[Double]

#
highest_priority

source
fn highest_priority(decisions : Array[RoutingDecision]) -> Int

#
histogram_distance

source
fn histogram_distance(left : Histogram, right : Histogram) -> Double

#
histogram_hellinger

source
fn histogram_hellinger(left : Histogram, right : Histogram) -> Double

#
incident_alert_count

source
fn incident_alert_count(incidents : Array[Incident]) -> Int

#
incident_rate

source
fn incident_rate(incidents : Array[Incident], start : Int64, end : Int64) -> Double

#
incidents_markdown

source
fn incidents_markdown(incidents : Array[Incident]) -> String

#
inspect_split

source
fn inspect_split(values : Array[Double], split : Int, min_segment? : Int) -> OfflineChange?

Returns a change record for a split, or None when the split is outside the valid range.

#
interpolate_missing

source
fn interpolate_missing(values : Array[Double]) -> Array[Double]

Linearly interpolates invalid observations while retaining valid endpoints.

#
interpolate_points

source
fn interpolate_points(points : Array[SignalPoint], step : Int64) -> Array[SignalPoint]

#
interquartile_range

source
fn interquartile_range(values : Array[Double]) -> Double

#
is_finite

source
fn is_finite(value : Double) -> Bool

Returns whether a value is finite enough for detector state.

#
ks_statistic

source
fn ks_statistic(left : Array[Double], right : Array[Double]) -> Double

Kolmogorov-Smirnov distance between two samples.

#
lag_points

source
fn lag_points(points : Array[SignalPoint], lag : Int64) -> Array[SignalPoint]

#
lag_values

source
fn lag_values(values : Array[Double], lag : Int) -> Array[Double]

#
lagged_correlation

source
fn lagged_correlation(left : Array[Double], right : Array[Double], lag : Int) -> Double

#
linear_slope

source
fn linear_slope(values : Array[Double]) -> Double

#
locate_time_window

source
fn locate_time_window(windows : Array[TimeWindow], timestamp : Int64) -> Int

#
make_explanation

source
fn make_explanation(result : DetectionResult, baseline : Double, observed : Double, detector : String) -> DetectionExplanation

#
make_time_windows

source
fn make_time_windows(start : Int64, end : Int64, width : Int64, step? : Int64) -> Array[TimeWindow]

#
mann_whitney_u

source
fn mann_whitney_u(left : Array[Double], right : Array[Double]) -> Double

#
mask_every

source
fn mask_every(values : Array[Double], period : Int, offset? : Int) -> Array[Double]

Applies deterministic missingness without changing the length of the sample.

#
mean

source
fn mean(values : Array[Double]) -> Double

#
mean_absolute_difference

source
fn mean_absolute_difference(values : Array[Double]) -> Double

#
mean_shift_score

source
fn mean_shift_score(values : Array[Double], split : Int, min_segment? : Int) -> Double

Standardized mean difference between two adjacent segments.

#
median

source
fn median(values : Array[Double]) -> Double

#
median_absolute_deviation

source
fn median_absolute_deviation(values : Array[Double]) -> Double

#
merge_nearby_changes

source
fn merge_nearby_changes(changes : Array[OfflineChange], minimum_distance : Int) -> Array[OfflineChange]

Removes candidates closer than minimum_distance, preserving the highest score.

#
metrics_markdown

source
fn metrics_markdown(metrics : ChangePointMetrics) -> String

#
moving_average

source
fn moving_average(values : Array[Double], window_size : Int) -> Array[Double]

#
moving_median

source
fn moving_median(values : Array[Double], window_size : Int) -> Array[Double]

#
normalize_minmax

source
fn normalize_minmax(values : Array[Double]) -> Array[Double]

#
normalize_range

source
fn normalize_range(values : Array[Double], minimum? : Double, maximum? : Double) -> Array[Double]

#
normalize_scores

source
fn normalize_scores(scores : Array[Double]) -> Array[Double]

#
normalize_zscore

source
fn normalize_zscore(values : Array[Double]) -> Array[Double]

#
online_detector_count

source
fn online_detector_count() -> Int

#
optimal_changepoints

source
fn optimal_changepoints(values : Array[Double], penalty? : Double, min_segment? : Int, max_changes? : Int) -> Array[Int]

Penalized dynamic programming for minimum-description-length style segmentation.

#
outlier_mask

source
fn outlier_mask(values : Array[Double], threshold? : Double) -> Array[Bool]

#
page_count

source
fn page_count(decisions : Array[RoutingDecision]) -> Int

#
percentile

source
fn percentile(values : Array[Double], percent : Double) -> Double

#
piecewise_constant_error

source
fn piecewise_constant_error(values : Array[Double], changes : Array[Int]) -> Double

Computes a reconstruction error when each segment is represented by its mean.

#
quality_gate

source
fn quality_gate(values : Array[Double], minimum_score? : Double) -> Bool

#
quality_score

source
fn quality_score(report : QualityReport) -> Double

#
quantile

source
fn quantile(values : Array[Double], probability : Double) -> Double

#
quantile_shift_score

source
fn quantile_shift_score(left : Array[Double], right : Array[Double]) -> Double

#
rank_biserial_effect

source
fn rank_biserial_effect(left : Array[Double], right : Array[Double]) -> Double

#
ranks

source
fn ranks(values : Array[Double]) -> Array[Double]

fn recommended_detector(multivariate : Bool, offline : Bool, robust : Bool) -> String

#
recovery_message

source
fn recovery_message(plan : RecoveryPlan) -> String

#
recovery_priority

source
fn recovery_priority(result : DetectionResult) -> Int

#
recovery_report

source
fn recovery_report(plans : Array[RecoveryPlan]) -> String

#
relative_change

source
fn relative_change(baseline : Double, observed : Double) -> Double

#
remove_invalid

source
fn remove_invalid(values : Array[Double]) -> Array[Double]

#
reorder_periodic

source
fn reorder_periodic(points : Array[SignalPoint], period : Int) -> Array[SignalPoint]

Reorders every period-th point to model a small late-data burst.

#
replace_invalid

source
fn replace_invalid(values : Array[Double], replacement? : Double) -> Array[Double]

#
replay_changed_indices

source
fn replay_changed_indices(records : Array[ReplayRecord]) -> Array[Int]

#
replay_checksum

source
fn replay_checksum(records : Array[ReplayRecord]) -> Double

#
replay_latency_percentile

source
fn replay_latency_percentile(records : Array[ReplayRecord], probability : Double) -> Int64

#
replay_summary_markdown

source
fn replay_summary_markdown(summary : ReplaySummary) -> String

#
replay_values

source
fn replay_values(records : Array[ReplayRecord]) -> Array[Double]

#
replay_window

source
fn replay_window(records : Array[ReplayRecord], start : Int, end : Int) -> Array[ReplayRecord]

#
resample_linear

source
fn resample_linear(points : Array[SignalPoint], step : Int64) -> Array[SignalPoint]

#
results_csv

source
fn results_csv(results : Array[DetectionResult]) -> String

#
robust_detector_count

source
fn robust_detector_count() -> Int

#
robust_scale

source
fn robust_scale(values : Array[Double]) -> Double

#
robust_z_score

source
fn robust_z_score(value : Double, center : Double, scale : Double) -> Double

#
robust_z_scores

source
fn robust_z_scores(values : Array[Double]) -> Array[Double]

#
rolling_correlation

source
fn rolling_correlation(left : Array[Double], right : Array[Double], window_size : Int) -> Array[Double]

#
rolling_mean

source
fn rolling_mean(values : Array[Double], window_size : Int) -> Array[Double]

#
rolling_origins

source
fn rolling_origins(length : Int, train_size : Int, horizon : Int, step? : Int) -> Array[SegmentRange]

#
rolling_quantile

source
fn rolling_quantile(values : Array[Double], window_size : Int, probability : Double) -> Array[Double]

#
rolling_slope

source
fn rolling_slope(values : Array[Double], window_size : Int) -> Array[Double]

#
rolling_standard_deviation

source
fn rolling_standard_deviation(values : Array[Double], window_size : Int) -> Array[Double]

#
route_alert

source
fn route_alert(alert : AlertEvent) -> RoutingDecision

#
route_alerts

source
fn route_alerts(alerts : Array[AlertEvent]) -> Array[RoutingDecision]

#
routing_summary

source
fn routing_summary(decisions : Array[RoutingDecision]) -> String

#
runs_test_score

source
fn runs_test_score(values : Array[Double]) -> Double

#
safe_correlation

source
fn safe_correlation(left : Array[Double], right : Array[Double]) -> Double

Cross-series relationship helpers for multivariate monitoring.

#
scale_profile

source
fn scale_profile(values : Array[Double], sizes : Array[Int]) -> Array[ScaleEvidence]

#
scenario_truth

source
fn scenario_truth(scenario : SignalScenario) -> Array[Int]

#
score_f1

source
fn score_f1(scores : Array[Double], labels : Array[Bool], threshold : Double) -> Double

#
score_margin

source
fn score_margin(score : Double, threshold : Double) -> Double

#
score_precision

source
fn score_precision(scores : Array[Double], labels : Array[Bool], threshold : Double) -> Double

#
score_recall

source
fn score_recall(scores : Array[Double], labels : Array[Bool], threshold : Double) -> Double

#
score_to_confidence

source
fn score_to_confidence(score : Double, threshold : Double) -> Double

#
seasonal_naive_forecast

source
fn seasonal_naive_forecast(values : Array[Double], period : Int, horizon : Int) -> Array[Double]

#
seasonal_strength

source
fn seasonal_strength(values : Array[Double], period : Int) -> Double

#
second_difference

source
fn second_difference(values : Array[Double]) -> Array[Double]

#
segment_means

source
fn segment_means(values : Array[Double], boundaries : Array[Int]) -> Array[Double]

#
segment_profile

source
fn segment_profile(values : Array[Double], boundaries : Array[Int]) -> Array[StatsSummary]

#
segment_quality

source
fn segment_quality(values : Array[Double]) -> SegmentQuality

#
segment_variances

source
fn segment_variances(values : Array[Double], boundaries : Array[Int]) -> Array[Double]

#
severity_from_score

source
fn severity_from_score(score : Double) -> AlertSeverity

Converts a score into a stable three-level severity.

#
severity_name

source
fn severity_name(severity : AlertSeverity) -> String

Returns a human-readable severity label.

#
should_escalate

source
fn should_escalate(plan : RecoveryPlan, score : Double) -> Bool

#
sigmoid_score

source
fn sigmoid_score(value : Double) -> Double

#
sign

source
fn sign(value : Double) -> Int

Returns the sign of a number.

#
sign_change_rate

source
fn sign_change_rate(values : Array[Double]) -> Double

#
signal_checksum

source
fn signal_checksum(values : Array[Double]) -> Double

Returns a deterministic checksum useful for detecting accidental benchmark dead-code elimination.

#
slope_confidence

source
fn slope_confidence(values : Array[Double]) -> Double

#
sorted_copy

source
fn sorted_copy(values : Array[Double]) -> Array[Double]

Returns a sorted copy using insertion sort. It is stable and allocation-bounded for small windows.

#
spearman_correlation

source
fn spearman_correlation(left : Array[Double], right : Array[Double]) -> Double

#
split_train_test

source
fn split_train_test(values : Array[Double], train_fraction? : Double) -> (Array[Double], Array[Double])

#
standard_deviation

source
fn standard_deviation(values : Array[Double]) -> Double

#
stratified_counts

source
fn stratified_counts(values : Array[Double], bins : Int) -> Array[Int]

#
strongest_contribution

source
fn strongest_contribution(explanation : DetectionExplanation) -> EvidenceContribution?

#
sum

source
fn sum(values : Array[Double]) -> Double

#
summarize_replay

source
fn summarize_replay(records : Array[ReplayRecord]) -> ReplaySummary

#
summary_markdown

source
fn summary_markdown(summary : StatsSummary) -> String

#
tail_confidence

source
fn tail_confidence(score : Double, scale? : Double) -> Double

#
threshold_for_false_positive

source
fn threshold_for_false_positive(scores : Array[Double], target_rate : Double) -> Double

#
threshold_from_mad

source
fn threshold_from_mad(scores : Array[Double], multiplier? : Double) -> Double

#
threshold_from_mean

source
fn threshold_from_mean(scores : Array[Double], standard_deviations? : Double) -> Double

#
threshold_from_quantile

source
fn threshold_from_quantile(scores : Array[Double], false_positive_rate : Double) -> Double

#
threshold_grid

source
fn threshold_grid(minimum : Double, maximum : Double, steps : Int) -> Array[Double]

#
threshold_points

source
fn threshold_points(scores : Array[Double], threshold : Double) -> Array[ThresholdPoint]

#
time_window_csv

source
fn time_window_csv(windows : Array[TimeWindow], counts : Array[Int]) -> String

#
timestamped_signal

source
fn timestamped_signal(values : Array[Double], start? : Int64, step? : Int64) -> Array[SignalPoint]

Converts a signal to timestamped points.

#
trimmed_mean

source
fn trimmed_mean(values : Array[Double], trim_fraction : Double) -> Double

#
validate_points

source
fn validate_points(points : Array[SignalPoint], maximum_gap? : Int64?) -> QualityReport

#
validate_values

source
fn validate_values(values : Array[Double], lower? : Double?, upper? : Double?) -> QualityReport

#
variance

source
fn variance(values : Array[Double]) -> Double

#
vector_dot

source
fn vector_dot(left : Array[Double], right : Array[Double]) -> Double

#
vector_norm

source
fn vector_norm(values : Array[Double]) -> Double

Computes the Euclidean norm of a vector.

#
weighted_consensus

source
fn weighted_consensus(results : Array[DetectionResult], weights : Array[Double], quorum : Double) -> DetectionResult

#
weighted_mean

source
fn weighted_mean(values : Array[Double], weights : Array[Double]) -> Double

#
window_change_scores

source
fn window_change_scores(values : Array[Double], min_segment? : Int) -> Array[Double]

Scans every valid split and returns a score for each index.

#
window_counts

source
fn window_counts(points : Array[SignalPoint], windows : Array[TimeWindow]) -> Array[Int]

#
window_means

source
fn window_means(points : Array[SignalPoint], windows : Array[TimeWindow]) -> Array[Double]

#
window_summaries

source
fn window_summaries(points : Array[SignalPoint], windows : Array[TimeWindow]) -> Array[StatsSummary]

#
winsorize

source
fn winsorize(values : Array[Double], lower_probability? : Double, upper_probability? : Double) -> Array[Double]

#
winsorize_robust

source
fn winsorize_robust(values : Array[Double], lower_probability : Double, upper_probability : Double) -> Array[Double]

Robust preprocessing helpers for production telemetry.

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io