moon-kalman
Production-ready MoonBit state estimation, smoothing, and sensor fusion library
kalman
filter
state-space
sensor-fusion
ekf
ukf
smoothing
moon add Lyllyl789/moon-kalman@0.2.1
Download zipAuthor
Version
0.2.1
License
Apache-2.0
Repository
Last updated
6 hours ago
Downloads
5
README#moon-kalman
MoonBit 状态估计、卡尔曼滤波与传感器融合库。
- GitHub：Lyllyl789/moon-kalman
- Mooncakes：Lyllyl789/moon-kalman
- 许可证：Apache-2.0
#项目定位
moon-kalman 面向需要在 MoonBit 中构建状态空间模型、处理含噪观测并融合多源传感器数据的应用。它覆盖从矩阵运算和滤波器更新，到数据质量、异常值门控、轨迹后处理和可复现实验的完整链路，适用于导航、机器人、物联网、设备监测和自动控制等场景。
项目以库 API 为中心，核心模块不依赖第三方 MoonBit 模块；仓库同时提供可运行示例和 native release 基准入口。
#核心能力
- 线性滤波：Kalman1D 和 KalmanND，支持预测、控制输入、部分观测、缺失观测、NIS 门控、Joseph 协方差更新、检查点和恢复。
- 非线性滤波：EKF 和 UKF，支持自定义状态转移、雅可比或 sigma 点、门控、缺失观测和诊断统计。
- 线性代数：向量/矩阵运算、LU 与部分选主元求解、矩阵逆、Cholesky、QR、最小二乘、特征值和条件数估计。
- 传感器处理：多传感器融合、校准、时间同步、数据质量审计、异常值降权、健康评分、有限缓存和遥测。
- 估计后处理：RTS 全平滑、固定时滞平滑、信号处理、轨迹分析、误差指标、模型选择、估计器集成和确定性回放。
- 几何与质量分析：三维坐标/姿态、鲁棒回归、异步传感器对时、批量估计、不确定性预算、轨迹质量、轨迹关联和模型目录。
- 运行时保护：事件时间窗口、流式游标、状态约束修复、安全包络、诊断快照和 CSV 导出。
- 输入保护：检查维度、非有限数、退化协方差和缺失数据；公开的数组与矩阵访问器返回副本。
#快速开始
使用 MoonBit stable 工具链，并在你的模块中添加依赖：
moon add Lyllyl789/moon-kalman@0.2.1在 moon.pkg 中导入包：
import {
"Lyllyl789/moon-kalman" @kalman,
}一个最小的标量滤波示例：
fn main {
let filter = @kalman.Kalman1D::new(0.0, 1.0, 0.02, 0.1)
filter.set_gate_threshold(9.210340371976184)
filter.predict_without_control()
let result = filter.update_if_valid(1.0)
println(
"result=\{@kalman.update_result_to_string(result)}, state=\{filter.state()}, variance=\{filter.uncertainty()}",
)
}#CLI 与可运行入口
本项目当前是库项目，没有独立安装型命令行工具；仓库提供以下可直接运行的 MoonBit executable package：
# 运行两路传感器融合示例
moon run examples/sensor_fusion
# 运行 native release 基准
moon run --target native --release benchmarks#架构
根目录是 Lyllyl789/moon-kalman 公共包，生成的 pkg.generated.mbti 用于记录公开 API。实现按职责划分为以下层次：
- 滤波与模型：kalman_1d.mbt、kalman_nd.mbt、ekf.mbt、ukf.mbt、models.mbt 和 control_models.mbt。
- 数学基础：matrix_types.mbt、matrix_arithmetic.mbt、matrix_decompose.mbt、linear_algebra_extra.mbt 和 vector_math.mbt。
- 质量与融合：fusion.mbt、fusion_strategies.mbt、calibration.mbt、data_quality.mbt、diagnostics.mbt、quality_control.mbt、sensor_runtime.mbt 和 telemetry.mbt。
- 几何、估计与对时：coordinate_frames.mbt、robust_estimation.mbt、sensor_alignment.mbt、batch_estimation.mbt 和 uncertainty_analysis.mbt。
- 运行时与安全：track_association.mbt、streaming_runtime.mbt、model_catalog.mbt、trajectory_quality.mbt、safety_constraints.mbt、state_constraints.mbt 和 diagnostic_export.mbt。
- 后处理与实验支持：smoother.mbt、replay.mbt、signal_processing.mbt、trajectory_tools.mbt、metrics.mbt、model_selection.mbt 和 simulation.mbt。
- 可执行包：examples/sensor_fusion 提供使用示例，benchmarks 提供确定性的 native release 基准。
当前源码规模快照如下。统计按物理行计数，排除 _build 和生成的 .mbti 文件；测试文件按文件名中的 _test.mbt 区分。
| 范围 | 文件数 | 行数 |
|---|---|---|
| 根库非测试 MoonBit 源码 | 46 | 19,963 |
| 示例与基准入口 | 2 | 81 |
| 仓库非测试 MoonBit 源码合计 | 48 | 20,044 |
| 测试 MoonBit 源码 | 16 | 2,418 |
这些是仓库规模的可复核快照，不代表算法质量或性能保证。
#基准
运行：
moon run --target native --release benchmarks基准使用确定性输入，并输出 checksum 以便复核。最近一次本地三次运行使用 Windows 11、AMD Ryzen 7 5800H、MoonBit stable 0.1.20260814，结果为：
| 场景 | 工作量 | 记录耗时 | 记录吞吐 |
|---|---|---|---|
| 标量更新 | 1,000,000 次 | 14–15 ms | 66.67–71.43 M updates/s |
| 4×2 矩阵更新 | 10,000 次 | 143–195 ms | 51.28–69.93 k updates/s |
标量 checksum 为 512911.08916493575，矩阵 checksum 为 9850.129406998216。这些是特定机器和工具链下的实测基线，会随硬件、系统负载和 MoonBit 版本变化；完整原始记录见 benchmarks/RESULTS.md。
#测试
当前测试套件包含 133 个测试声明，覆盖矩阵边界、奇异和退化协方差、空输入、维度错误、非有限输入、门限拒绝、丢包、回放、运行时健康状态、轨迹、异步对时、鲁棒估计、关联、流式运行时、安全约束和诊断导出。
本地运行完整验证：
moon check --target all --deny-warn
moon build --target all --deny-warn
moon test --target all --deny-warnnative 覆盖率：
moon test --target native --deny-warn --enable-coverage
moon coverage report -f summary#CI
test.yml 在 Ubuntu、macOS 和 Windows 上安装官方 MoonBit stable 工具链，并执行：
moon version --all
moon update
moon check --target all --deny-warn
moon build --target all --deny-warn
moon test --target all --deny-warn
moon run examples/sensor_fusion
moon fmt && git diff --exit-code
moon info && git diff --exit-codeCI 另有 native 覆盖率 job。Mooncakes 发布通过 publish.yml 手动触发，凭据只从 GitHub Actions secret 读取，不写入仓库。
#许可证
本项目采用 Apache License 2.0。
#AdaptiveNoiseController
pub struct AdaptiveNoiseController {
process_scale : Double
measurement_scale : Double
minimum_scale : Double
maximum_scale : Double
target_nis : Double
learning_rate : Double
}#AdaptiveNoiseController::measurement_scale
#AdaptiveNoiseController::new
fn AdaptiveNoiseController::new(minimum_scale : Double, maximum_scale : Double, target_nis : Double, learning_rate : Double) -> AdaptiveNoiseController#AdaptiveNoiseController::observe
#AdaptiveNoiseController::process_scale
#AlignedVector
pub struct AlignedVector {
timestamp : Int
values : Array[Double]
status : AlignmentStatus
source_timestamp : Int
quality : Double
distance : Int
} derive(Debug)A value aligned to a requested timestamp.
#AlignedVector::distance
Return absolute source/target distance.
#AlignedVector::is_present
Return whether alignment produced a value.
#AlignedVector::new
fn AlignedVector::new(timestamp : Int, values : Array[Double], status : AlignmentStatus, source_timestamp : Int, quality : Double, distance : Int) -> AlignedVectorConstruct an aligned vector.
#AlignedVector::quality
Return propagated quality.
#AlignedVector::source_timestamp
Return source timestamp.
#AlignedVector::status
Return status.
#AlignedVector::timestamp
Return target timestamp.
#AlignedVector::values
Return aligned values.
#AlignmentPolicy
pub struct AlignmentPolicy {
tolerance : Int
max_gap : Int
allow_extrapolation : Bool
minimum_quality : Double
} derive(Debug)A policy controlling interpolation and gap handling.
#AlignmentPolicy::allow_extrapolation
Return extrapolation policy.
#AlignmentPolicy::max_gap
Return maximum interpolation gap.
#AlignmentPolicy::minimum_quality
Return minimum acceptable quality.
#AlignmentPolicy::new
fn AlignmentPolicy::new(tolerance : Int, max_gap : Int, allow_extrapolation : Bool, minimum_quality : Double) -> AlignmentPolicyConstruct an alignment policy.
#AlignmentPolicy::tolerance
Return timestamp tolerance.
#AlignmentReport
pub struct AlignmentReport {
requested : Int
produced : Int
exact : Int
nearest : Int
interpolated : Int
extrapolated : Int
missing : Int
invalid : Int
maximum_distance : Int
mean_distance : Double
} derive(Debug)A summary of an alignment pass.
#AlignmentReport::coverage
Return the produced fraction.
#AlignmentReport::exact
Return exact count.
#AlignmentReport::extrapolated
Return extrapolated count.
#AlignmentReport::interpolated
Return interpolated count.
#AlignmentReport::invalid
Return invalid count.
#AlignmentReport::maximum_distance
Return maximum timestamp distance.
#AlignmentReport::mean_distance
Return mean timestamp distance.
#AlignmentReport::missing
Return missing count.
#AlignmentReport::nearest
Return nearest count.
#AlignmentReport::produced
Return produced count.
#AlignmentReport::requested
Return requested count.
#AlignmentReport::usable_coverage
Return the fraction produced by interpolation or exact matching.
#AlignmentStatus
The outcome class of a timestamp alignment query.
#AssociationBatch
pub struct AssociationBatch {
decisions : Array[AssociationDecision]
candidates : Array[AssociationCandidate]
unmatched_measurements : Array[Int]
total_cost : Double
accepted_count : Int
} derive(Debug)The result of one batch assignment.
#AssociationBatch::acceptance_rate
#AssociationBatch::accepted_count
#AssociationBatch::candidates
#AssociationBatch::decisions
#AssociationBatch::new
fn AssociationBatch::new(decisions : Array[AssociationDecision], candidates : Array[AssociationCandidate], unmatched_measurements : Array[Int]) -> AssociationBatch#AssociationBatch::total_cost
#AssociationBatch::unmatched_measurements
#AssociationCandidate
pub struct AssociationCandidate {
track_id : Int
measurement_id : Int
distance : Double
likelihood : Double
gated : Bool
metric : String
} derive(Debug)A candidate produced by comparing one predicted track with one measurement.
#AssociationCandidate::distance
#AssociationCandidate::gated
#AssociationCandidate::likelihood
#AssociationCandidate::measurement_id
#AssociationCandidate::metric
#AssociationCandidate::new
fn AssociationCandidate::new(track_id : Int, measurement_id : Int, distance : Double, likelihood : Double, gated : Bool, metric : String) -> AssociationCandidateConstruct a candidate and normalize invalid scores.
#AssociationCandidate::track_id
#AssociationConfig
pub struct AssociationConfig {
gate_threshold : Double
minimum_likelihood : Double
miss_cost : Double
allow_reuse : Bool
prefer_likelihood : Bool
} derive(Debug)Gating and assignment policy for a sensor update.
#AssociationConfig::allow_reuse
#AssociationConfig::gate_threshold
#AssociationConfig::minimum_likelihood
#AssociationConfig::miss_cost
#AssociationConfig::new
fn AssociationConfig::new(gate_threshold : Double, minimum_likelihood : Double, miss_cost : Double) -> AssociationConfig#AssociationConfig::prefer_likelihood
#AssociationConfig::with_likelihood_priority
fn AssociationConfig::with_likelihood_priority(self : AssociationConfig, enabled : Bool) -> AssociationConfig#AssociationConfig::with_reuse
#AssociationDecision
pub struct AssociationDecision {
track_id : Int
measurement_id : Int?
distance : Double
confidence : Double
accepted : Bool
reason : String
} derive(Debug)A decision for a single track after global assignment.
#AssociationDecision::accepted
fn AssociationDecision::accepted(track_id : Int, measurement_id : Int, distance : Double, confidence : Double, reason : String) -> AssociationDecision#AssociationDecision::confidence
#AssociationDecision::distance
#AssociationDecision::is_accepted
#AssociationDecision::measurement_id
#AssociationDecision::reason
#AssociationDecision::track_id
#AssociationDecision::unmatched
#BatchFitResult
A result returned by batch least-squares routines.
#BatchFitResult::coefficients
Return fitted coefficients.
#BatchFitResult::condition
Return design matrix condition estimate.
#BatchFitResult::covariance
Return coefficient covariance.
#BatchFitResult::iterations
Return the number of solver iterations.
#BatchFitResult::mae
Return mean absolute error.
#BatchFitResult::r_squared
Return coefficient of determination.
#BatchFitResult::residuals
Return residuals.
#BatchFitResult::rmse
Return root mean square error.
#BatchFitResult::success
Return whether fitting succeeded.
#BatchFitResult::weights
Return final observation weights.
#BatchGate
pub struct BatchGate {
policy : ResidualPolicy
inspected : Int
accepted : Int
downweighted : Int
rejected : Int
}A small batch gate that turns individual residual decisions into one
packet-level decision and exposes a stable covariance inflation factor.
#BatchGate::inspect
#BatchObservation
A scalar observation for batch regression. features are copied so a
caller can reuse its input buffer after submitting the observation.
#BatchObservation::features
Return the feature vector.
#BatchObservation::is_valid
Return whether the observation is finite and usable.
#BatchObservation::new
fn BatchObservation::new(features : Array[Double], value : Double, weight : Double, timestamp : Int) -> BatchObservationConstruct a batch observation.
#BatchObservation::timestamp
Return observation timestamp.
#BatchObservation::value
Return the observed value.
#BatchObservation::weight
Return observation weight.
#CalibrationTransform
Affine calibration transform applied component-wise to raw readings.
#CalibrationTransform::apply
fn CalibrationTransform::apply(self : CalibrationTransform, values : Array[Double]) -> Array[Double]#CalibrationTransform::dimension
#CalibrationTransform::identity
#CalibrationTransform::inverse
fn CalibrationTransform::inverse(self : CalibrationTransform, values : Array[Double]) -> Array[Double]#CalibrationTransform::new
#CalibrationTransform::offset
#CalibrationTransform::scale
#ConfidenceBand
pub struct ConfidenceBand {
estimate : Double
lower : Double
upper : Double
standard_deviation : Double
multiplier : Double
valid : Bool
} derive(Debug)A scalar confidence interval with an explicit confidence multiplier.
#ConfidenceBand::contains
Return whether a value is inside the band.
#ConfidenceBand::estimate
Return estimate.
#ConfidenceBand::lower
Return lower bound.
#ConfidenceBand::multiplier
Return confidence multiplier.
#ConfidenceBand::new
fn ConfidenceBand::new(estimate : Double, standard_deviation : Double, multiplier : Double) -> ConfidenceBandConstruct a confidence band from an estimate and standard deviation.
#ConfidenceBand::standard_deviation
Return standard deviation.
#ConfidenceBand::upper
Return upper bound.
#ConfidenceBand::width
Return interval width.
#ConsistencyReport
pub struct ConsistencyReport {
count : Int
average_nees : Double
average_nis : Double
accepted_rate : Double
covariance_failures : Int
} derive(Debug)#ConsistencyReport::accepted_rate
#ConsistencyReport::average_nees
#ConsistencyReport::average_nis
#ConsistencyReport::covariance_failures
#ConstantVelocityTracker2D
pub struct ConstantVelocityTracker2D {
filter : KalmanND
acceleration_variance : Double
position_variance : Double
last_timestamp : Int
initialized_timestamp : Bool
}A ready-to-use two-dimensional position tracker with state
[x, y, vx, vy] and a position measurement [x, y].
#ConstantVelocityTracker2D::covariance
#ConstantVelocityTracker2D::filter
#ConstantVelocityTracker2D::new
fn ConstantVelocityTracker2D::new(initial_position : Array[Double], initial_velocity : Array[Double], initial_variance : Double, acceleration_variance : Double, position_variance : Double) -> ConstantVelocityTracker2D#ConstantVelocityTracker2D::predict
#ConstantVelocityTracker2D::reset
#ConstantVelocityTracker2D::set_gate_threshold
fn ConstantVelocityTracker2D::set_gate_threshold(self : ConstantVelocityTracker2D, threshold : Double) -> Unit#ConstantVelocityTracker2D::state
#ConstantVelocityTracker2D::step
fn ConstantVelocityTracker2D::step(self : ConstantVelocityTracker2D, timestamp : Int, position : Array[Double], covariance : Matrix) -> UpdateResult#ConstantVelocityTracker2D::step_position
fn ConstantVelocityTracker2D::step_position(self : ConstantVelocityTracker2D, timestamp : Int, x : Double, y : Double) -> UpdateResult#ContractIssue
pub struct ContractIssue {
code : String
severity : ContractSeverity
message : String
} derive(Debug)#ContractIssue::new
fn ContractIssue::new(code : String, severity : ContractSeverity, message : String) -> ContractIssue#ContractSeverity
Severity attached to a machine-readable validation issue.
#ControlCommand
#ControlCommand::new
fn ControlCommand::new(timestamp : Int, values : Array[Double], duration : Double) -> ControlCommand#ControlIntegrator
pub struct ControlIntegrator {
dimension : Int
state : Array[Double]
limits : ControlLimits
response : Double
}Integrate a first-order control response with a bounded acceleration.
#ControlIntegrator::new
fn ControlIntegrator::new(dimension : Int, limits : ControlLimits, response : Double) -> ControlIntegrator#ControlIntegrator::response
#ControlIntegrator::state
#ControlIntegrator::step
fn ControlIntegrator::step(self : ControlIntegrator, command : Array[Double], dt : Double) -> Array[Double]#ControlLimits
Saturation limits for an actuator or control input.
#ControlLimits::apply
#ControlLimits::contains
#ControlLimits::new
#ControlSequence
A bounded command sequence for offline control replay.
#ControlSequence::commands
#ControlSequence::push
#CovarianceAccumulator
Accumulate covariance from a stream without storing every sample.
#CovarianceAccumulator::add
#CovarianceAccumulator::count
#CovarianceAccumulator::covariance
#CovarianceAccumulator::mean
#CovarianceAccumulator::new
#CovarianceAccumulator::reset
#CovarianceHealth
#CovarianceReport
pub struct CovarianceReport {
health : CovarianceHealth
dimension : Int
symmetry_error : Double
minimum_eigenvalue : Double
maximum_eigenvalue : Double
condition_estimate : Double
finite : Bool
positive_diagonal : Bool
} derive(Debug)#CovarianceReport::condition_estimate
#CovarianceReport::health
#CovarianceReport::maximum_eigenvalue
#CovarianceReport::minimum_eigenvalue
#CovarianceReport::positive_diagonal
#CovarianceReport::symmetry_error
#CovarianceSummary
pub struct CovarianceSummary {
dimension : Int
trace : Double
determinant : Double
minimum_diagonal : Double
maximum_diagonal : Double
condition : Double
rank : Int
symmetric : Bool
positive_diagonal : Bool
finite : Bool
} derive(Debug)A summary of covariance health and scale.
#CovarianceSummary::condition
Return condition estimate.
#CovarianceSummary::determinant
Return determinant.
#CovarianceSummary::dimension
Return covariance dimension.
#CovarianceSummary::finite
Return finite status.
#CovarianceSummary::maximum_diagonal
Return maximum diagonal.
#CovarianceSummary::minimum_diagonal
Return minimum diagonal.
#CovarianceSummary::positive_diagonal
Return positive-diagonal status.
#CovarianceSummary::rank
Return numerical rank.
#CovarianceSummary::symmetric
Return symmetry status.
#CovarianceSummary::trace
Return trace.
#CovarianceSummary::usable
Return whether covariance is suitable for confidence reporting.
#DataQualityReport
pub struct DataQualityReport {
total : Int
valid : Int
missing : Int
non_finite : Int
non_monotonic_timestamps : Int
duplicate_timestamps : Int
finite_fraction : Double
} derive(Debug)Data-quality summary for a timestamped sensor stream.
#DataQualityReport::duplicate_timestamps
#DataQualityReport::finite_fraction
#DataQualityReport::non_finite
#DataQualityReport::non_monotonic_timestamps
#DeterministicRng
pub struct DeterministicRng {
state : Int
}Small deterministic pseudo-random generator for repeatable examples and
benchmarks. It is not intended for cryptographic use.
#DeterministicRng::bounded_int
#DeterministicRng::symmetric
#DiagnosticAccumulator
pub struct DiagnosticAccumulator {
reports : Array[DiagnosticReport]
capacity : Int
discarded : Int
} derive(Debug)#DiagnosticAccumulator::average_score
#DiagnosticAccumulator::discarded
#DiagnosticAccumulator::healthy_fraction
#DiagnosticAccumulator::length
#DiagnosticAccumulator::new
#DiagnosticAccumulator::push
#DiagnosticAccumulator::reports
#DiagnosticEvent
pub struct DiagnosticEvent {
timestamp : Int
code : String
severity : DiagnosticSeverity
message : String
value : Double
acknowledged : Bool
} derive(Debug)#DiagnosticEvent::acknowledged
#DiagnosticEvent::new
fn DiagnosticEvent::new(timestamp : Int, code : String, severity : DiagnosticSeverity, message : String, value : Double) -> DiagnosticEvent#DiagnosticEvent::severity
#DiagnosticEvent::severity_text
#DiagnosticField
pub struct DiagnosticField {
name : String
value : Double
unit : String
category : String
healthy : Bool
} derive(Debug)A named diagnostic value suitable for logs, dashboards and CSV export.
#DiagnosticField::new
fn DiagnosticField::new(name : String, value : Double, unit : String, category : String, healthy : Bool) -> DiagnosticField#DiagnosticReport
pub struct DiagnosticReport {
run_id : String
started_at : Int
finished_at : Int?
snapshots : Array[DiagnosticSnapshot]
events : Array[DiagnosticEvent]
closed : Bool
} derive(Debug)#DiagnosticReport::add_event
#DiagnosticReport::add_snapshot
#DiagnosticReport::close
#DiagnosticReport::events
#DiagnosticReport::events_csv
#DiagnosticReport::finished_at
#DiagnosticReport::new
#DiagnosticReport::snapshots
#DiagnosticReport::snapshots_csv
#DiagnosticSeverity
#DiagnosticSnapshot
pub struct DiagnosticSnapshot {
timestamp : Int
source : String
fields : Array[DiagnosticField]
state_dimension : Int
covariance_dimension : Int
healthy : Bool
score : Double
} derive(Debug)#DiagnosticSnapshot::covariance_dimension
#DiagnosticSnapshot::csv_header
#DiagnosticSnapshot::csv_row
#DiagnosticSnapshot::field
#DiagnosticSnapshot::fields
#DiagnosticSnapshot::new
fn DiagnosticSnapshot::new(timestamp : Int, source : String, fields : Array[DiagnosticField], state_dimension : Int, covariance_dimension : Int) -> DiagnosticSnapshot#DiagnosticSnapshot::state_dimension
#DiagnosticSnapshot::timestamp
#DominantEigenpair
One power-iteration estimate of the dominant eigenpair.
#DominantEigenpair::converged
#DominantEigenpair::iterations
#DominantEigenpair::vector
#EKF
pub struct EKF {
x : Array[Double]
p : Matrix
q : Matrix
r : Matrix
initial_state : Array[Double]
initial_covariance : Matrix
last_innovation : Array[Double]
last_innovation_covariance : Matrix
last_gain : Matrix
last_nis : Double
gate_threshold : Double
predict_count : Int
accepted_count : Int
rejected_count : Int
missing_count : Int
}Extended Kalman Filter for differentiable non-linear models.
Callers provide the state transition and observation functions together
with their Jacobians. All covariance updates use the same numerically
stable Joseph form as KalmanND.
#EKF::filter
Run a sequence of EKF updates against a caller-owned model.
#EKF::new
#EKF::normalized_innovation_squared
#EKF::predict
#EKF::predict_with_control
#EKF::set_measurement_noise
#EKF::update
#EKF::update_gated
#ErrorMetrics
pub(all) struct ErrorMetrics {
count : Int
rmse : Double
mae : Double
max_error : Double
final_error : Double
} derive(Debug)Common quality metrics for state-estimation experiments.
#Estimate1D
A one-dimensional estimate and its uncertainty.
#EstimatorEnsemble
Weighted consensus over a set of independent state estimates.
#EstimatorEnsemble::add
#EstimatorEnsemble::best
#EstimatorEnsemble::candidates
#EstimatorEnsemble::consensus
#EstimatorEnsemble::consensus_covariance
#EstimatorEnsemble::disagreement
#ExponentialStats
pub struct ExponentialStats {
alpha : Double
count : Int
mean : Double
variance : Double
minimum : Double
maximum : Double
}Exponentially weighted scalar statistics for non-stationary sensors.
#ExponentialStats::add
#ExponentialStats::standard_deviation
#FeatureVector
pub struct FeatureVector {
mean : Double
variance : Double
slope : Double
minimum : Double
maximum : Double
energy : Double
} derive(Debug)#FilterCheckpoint
A serializable-in-memory checkpoint for crash recovery and replay.
#FilterCheckpoint::covariance
#FilterCheckpoint::new
fn FilterCheckpoint::new(state : Array[Double], covariance : Matrix, timestamp : Int) -> FilterCheckpoint#FilterStatus
Runtime health classification for an on-device filter.
#FixedLagSmoother
Fixed-lag history manager. It stores the data needed to smooth a bounded
recent window while returning the newest filtered estimate immediately.
#FixedLagSmoother::latest_smoothed_state
#FixedLagSmoother::push
fn FixedLagSmoother::push(self : FixedLagSmoother, filtered_state : Array[Double], filtered_covariance : Matrix, predicted_state : Array[Double], predicted_covariance : Matrix, transition : Matrix) -> Unit#FixedLagSmoother::smooth
#FusionEvent
pub struct FusionEvent {
timestamp : Int
sensor : String
result : UpdateResult
state : Array[Double]
covariance : Matrix
nis : Double
} derive(Debug)#FusionMeasurement
#FusionMeasurement::confidence
#FusionMeasurement::covariance
#FusionMeasurement::is_valid
#FusionMeasurement::new
fn FusionMeasurement::new(sensor : String, timestamp : Int, values : Array[Double], covariance : Matrix, confidence : Double) -> FusionMeasurement#FusionMeasurement::values
#FusionPolicy
pub struct FusionPolicy {
gate_threshold : Double
max_time_gap : Int
covariance_inflation : Double
reject_non_finite : Bool
predict_on_missing : Bool
} derive(Debug)Policy for multi-sensor fusion and outlier handling.
#FusionPolicy::covariance_inflation
#FusionPolicy::new
fn FusionPolicy::new(gate_threshold : Double, max_time_gap : Int, covariance_inflation : Double, reject_non_finite : Bool, predict_on_missing : Bool) -> FusionPolicy#FusionPolicy::predict_on_missing
#FusionPolicy::reject_non_finite
#FusionResult
pub struct FusionResult {
strategy : FusionStrategy
timestamp : Int
values : Array[Double]
covariance : Matrix
used : Int
rejected : Int
} derive(Debug)#FusionStatistics
pub struct FusionStatistics {
total_packets : Int
accepted_packets : Int
rejected_packets : Int
missing_packets : Int
last_timestamp : Int
} derive(Debug)#FusionStatistics::accepted_packets
#FusionStatistics::last_timestamp
#FusionStatistics::missing_packets
#FusionStatistics::rejected_packets
#FusionStatistics::total_packets
#FusionStrategy
How independent measurements are combined before the state update.
#GateSchedule
pub struct GateSchedule {
base_threshold : Double
minimum_threshold : Double
maximum_threshold : Double
consecutive_rejections : Int
recovery_steps : Int
}#GateSchedule::consecutive_rejections
#GateSchedule::new
fn GateSchedule::new(base_threshold : Double, minimum_threshold : Double, maximum_threshold : Double, recovery_steps : Int) -> GateSchedule#GateSchedule::observe
#Histogram
pub struct Histogram {
minimum : Double
maximum : Double
buckets : Array[HistogramBucket]
underflow : Int
overflow : Int
samples : Int
}#Histogram::new
#Histogram::percentile
#HistogramBucket
A fixed-width histogram for telemetry and residual distributions.
#InnovationDiagnostics
#InnovationDiagnostics::accepted
#InnovationDiagnostics::covariance
#InnovationDiagnostics::innovation
#InnovationDiagnostics::nis
#InnovationDiagnostics::whitened_norm
#InnovationMonitor
pub struct InnovationMonitor {
dimension : Int
threshold : Double
samples : Int
accepted : Int
rejected : Int
nis_stats : RunningStats
last_nis : Double
}Online innovation monitor used as a quality gate and alert source.
#InnovationMonitor::acceptance_rate
#InnovationMonitor::average_nis
#InnovationMonitor::last_nis
#InnovationMonitor::new
#InnovationMonitor::observe
fn InnovationMonitor::observe(self : InnovationMonitor, innovation : Array[Double], covariance : Matrix) -> Bool#Kalman1D
pub struct Kalman1D {
x : Double
p : Double
q : Double
r : Double
initial_state : Double
initial_uncertainty : Double
last_innovation : Double
last_innovation_variance : Double
last_gain : Double
last_nis : Double
gate_threshold : Double
predict_count : Int
accepted_count : Int
rejected_count : Int
missing_count : Int
}A production-ready scalar Kalman filter for cheap sensor smoothing.
#Kalman1D::adapt_process_noise
Adapt process noise using the latest innovation while bounding changes.
#Kalman1D::filter
Smooth a whole scalar measurement series and return the state history.
#Kalman1D::new
#Kalman1D::normalized_innovation_squared
#Kalman1D::predict_without_control
#Kalman1D::set_gate_threshold
#Kalman1D::set_measurement_noise
#Kalman1D::set_process_noise
#Kalman1D::update_gated
#Kalman1D::update_if_valid
#KalmanDiagnostics
Namespace object for covariance and observation diagnostics.
#KalmanDiagnostics::check_covariance
fn KalmanDiagnostics::check_covariance(self : KalmanDiagnostics, covariance : Array[Array[Double]]) -> BoolCompatibility helper for the original API.
#KalmanDiagnostics::report
Inspect symmetry, finite values, diagonal signs, approximate eigenvalues,
and conditioning of a covariance matrix.
#KalmanND
pub struct KalmanND {
x : Array[Double]
p : Matrix
q : Matrix
r : Matrix
f : Matrix
h : Matrix
initial_state : Array[Double]
initial_covariance : Matrix
last_innovation : Array[Double]
last_innovation_covariance : Matrix
last_gain : Matrix
last_nis : Double
gate_threshold : Double
predict_count : Int
accepted_count : Int
rejected_count : Int
missing_count : Int
}Linear Kalman filter for dense state and measurement vectors.
The implementation uses the Joseph covariance form. Compared with the
short textbook form, Joseph form better preserves symmetry and positive
semidefiniteness when a sensor has very small noise.
#KalmanND::checkpoint
#KalmanND::filter
Run a predict/update cycle for each measurement and return state history.
#KalmanND::from_model
fn KalmanND::from_model(model : LinearModel, initial_state : Array[Double], initial_covariance : Matrix) -> KalmanND#KalmanND::inflate_covariance
Inflate covariance after a long sensor outage, with a hard cap for safety.
#KalmanND::new
#KalmanND::normalized_innovation_squared
#KalmanND::predict_with_control
Predict with an optional control vector. A zero-column control matrix is a
valid model, so callers can use an empty vector for the no-control case.
#KalmanND::predict_with_control_matrix
Predict with a caller-supplied state-space control effect matrix.
#KalmanND::restore
Restore a validated state/covariance pair, useful for checkpoint recovery.
#KalmanND::restore_checkpoint
#KalmanND::set_gate_threshold
#KalmanND::set_measurement_noise
#KalmanND::set_observation_model
#KalmanND::set_process_noise
#KalmanND::set_transition_model
#KalmanND::update
#KalmanND::update_and_report
#KalmanND::update_gated
fn KalmanND::update_gated(self : KalmanND, measurement : Array[Double], threshold : Double) -> UpdateResult#LinearModel
A complete linear state-space model for a sensor-fusion pipeline.
#LinearModel::measurement_dimension
#LinearModel::measurement_noise
#LinearModel::new
fn LinearModel::new(transition : Matrix, process_noise : Matrix, observation : Matrix, measurement_noise : Matrix, control : Matrix) -> LinearModel#Matrix
A compact row-major dense matrix used by the filtering algorithms.
Matrix deliberately keeps its storage private. This prevents callers
from accidentally changing the shape while still allowing the numerical
kernels to update values in place. The type is small enough for embedded
and WebAssembly workloads and predictable enough for deterministic tests.
#Matrix::add
Add two matrices. Invalid shapes produce a zero-sized matrix rather than
allowing a partially computed result into a filter.
#Matrix::approx_equal
#Matrix::block_diagonal
Construct a block diagonal matrix from independent square blocks.
#Matrix::cholesky
Lower-triangular Cholesky factor. The result is None when the input is
not symmetric positive definite.
#Matrix::clamp_diagonal
#Matrix::column
Return the requested column as a new owned array.
#Matrix::determinant
Determinant computed with partial pivoting. A zero result means that the
matrix is singular or not square.
#Matrix::diagonal
Construct a matrix whose diagonal is value and whose other entries are
zero.
#Matrix::dominant_eigenpair
#Matrix::fill
Fill every entry with the same value.
#Matrix::frobenius_norm
Frobenius norm, useful for residual and convergence checks.
#Matrix::from_flat
Construct a matrix from a flat row-major buffer. Short buffers are padded
with zeroes and long buffers are safely truncated.
#Matrix::from_rows
Construct a matrix from rows. Ragged rows are accepted and missing cells
are filled with zero; use try_from_rows when shape validation is needed.
#Matrix::get
Read an entry. This method is intended for validated matrix operations;
use try_get when coordinates originate outside the algorithm.
#Matrix::horizontal_concat
#Matrix::infinity_norm
Infinity norm: maximum absolute row sum.
#Matrix::inverse
Invert a matrix with the same pivoting strategy used by solve.
#Matrix::is_diagonally_dominant
#Matrix::jacobi_eigenvalues
Jacobi sweeps for a symmetric matrix. It is intentionally bounded: a
diagnostic should always return even for malformed field data.
#Matrix::least_squares
Least-squares solution using QR decomposition.
#Matrix::map
Apply a scalar function to every entry.
#Matrix::map_indexed
Apply a function with row and column coordinates to every entry.
#Matrix::multiply
General dense matrix multiplication.
#Matrix::multiply_vector
#Matrix::one_norm
One norm: maximum absolute column sum.
#Matrix::qr_decompose
QR decomposition by modified Gram-Schmidt. The returned pair is (Q, R)
with orthonormal columns in Q and an upper-triangular R.
#Matrix::rank
Rank estimate based on pivot magnitudes.
#Matrix::regularized_cholesky
Add a small diagonal jitter until Cholesky succeeds or the budget is
exhausted. This is useful for covariance matrices assembled from noisy
samples.
#Matrix::regularized_least_squares
fn Matrix::regularized_least_squares(self : Matrix, rhs : Array[Double], regularization : Double) -> MatrixSolveResultTikhonov-regularized least squares for rank-deficient design matrices.
#Matrix::replace_block
Replace a block in a copy of the matrix. The source must fit completely.
#Matrix::row
Return the requested row as a new owned array.
#Matrix::set
Set an entry when coordinates are valid. Returns whether the write was
performed.
#Matrix::slice
Extract a submatrix using half-open row and column ranges.
#Matrix::solve
Solve A x = b with partial pivoting.
#Matrix::to_rows
Convert to independent row arrays for interop and inspection.
#Matrix::try_from_rows
Construct a matrix only when all rows have the same width.
#Matrix::try_get
Read an entry without risking an out-of-bounds panic.
#Matrix::valid_index
Return whether a pair of coordinates is safe to access.
#Matrix::with_diagonal
#MatrixSolveResult
A result returned by a matrix operation that may be singular.
#MeasurementSchedule
pub struct MeasurementSchedule {
period : Int
elapsed : Int
}#MeasurementSchedule::elapsed
#MeasurementWindow
pub struct MeasurementWindow {
measurements : Array[FusionMeasurement]
capacity : Int
dimension : Int
}Bounded multi-sensor measurement collection.
#MeasurementWindow::fuse
#MeasurementWindow::measurements
#MeasurementWindow::new
#MeasurementWindow::push
#MissingObservationAction
#MissingObservationPolicy
pub struct MissingObservationPolicy {
max_consecutive : Int
inflate_factor : Double
action : MissingObservationAction
} derive(Debug)#MissingObservationPolicy::action
#MissingObservationPolicy::inflate_factor
#MissingObservationPolicy::max_consecutive
#MissingObservationPolicy::new
fn MissingObservationPolicy::new(max_consecutive : Int, inflate_factor : Double, action : MissingObservationAction) -> MissingObservationPolicy#ModelCatalog
pub struct ModelCatalog {
entries : Array[ModelCatalogEntry]
active_identity : String?
max_entries : Int
registrations : Int
selections : Int
} derive(Debug)Versioned model catalog with explicit activation and selection.
#ModelCatalog::activate
#ModelCatalog::active_identity
#ModelCatalog::enable
#ModelCatalog::entries
#ModelCatalog::find
#ModelCatalog::register
#ModelCatalog::select
#ModelCatalog::select_or_active
fn ModelCatalog::select_or_active(self : ModelCatalog, policy : ModelSelectionPolicy) -> ModelSelectionResult#ModelCatalog::unregister
#ModelCatalogEntry
Metadata and runtime score for one deployable estimation model.
#ModelCatalogEntry::compatible
fn ModelCatalogEntry::compatible(self : ModelCatalogEntry, dimension : Int, required_tags : Array[String]) -> Bool#ModelCatalogEntry::has_tag
#ModelCatalogEntry::identity
#ModelCatalogEntry::latency_ms
#ModelCatalogEntry::memory_bytes
#ModelCatalogEntry::new
fn ModelCatalogEntry::new(name : String, version : String, dimension : Int, metric : String, score : Double, latency_ms : Double, memory_bytes : Int, tags : Array[String]) -> ModelCatalogEntry#ModelCatalogEntry::record_use
#ModelCatalogEntry::set_enabled
#ModelCatalogEntry::with_score
fn ModelCatalogEntry::with_score(self : ModelCatalogEntry, score : Double, latency_ms : Double) -> ModelCatalogEntry#ModelEvaluation
A scored evaluation returned by model selection.
#ModelEvaluation::new
fn ModelEvaluation::new(entry : ModelCatalogEntry, eligible : Bool, normalized_score : Double, reasons : Array[String]) -> ModelEvaluation#ModelEvaluation::normalized_score
#ModelRegistry
A reusable collection of linear models for a fixed state dimension.
#ModelRegistry::add
#ModelRegistry::model
#ModelScore
pub struct ModelScore {
name : String
rmse : Double
mae : Double
complexity : Int
consistency : Double
} derive(Debug)Evidence collected while comparing a candidate model against observations.
#ModelScore::new
fn ModelScore::new(name : String, rmse : Double, mae : Double, complexity : Int, consistency : Double) -> ModelScore#ModelScore::objective
#ModelSelectionPolicy
Selection policy used to turn offline metrics into a deployable choice.
#ModelSelectionPolicy::dimension
#ModelSelectionPolicy::for_dimension
fn ModelSelectionPolicy::for_dimension(self : ModelSelectionPolicy, dimension : Int) -> ModelSelectionPolicy#ModelSelectionPolicy::higher_is_better
#ModelSelectionPolicy::max_latency_ms
#ModelSelectionPolicy::max_memory_bytes
#ModelSelectionPolicy::metric
#ModelSelectionPolicy::minimum_score
#ModelSelectionPolicy::new
fn ModelSelectionPolicy::new(metric : String, higher_is_better : Bool, max_latency_ms : Double, max_memory_bytes : Int, minimum_score : Double) -> ModelSelectionPolicy#ModelSelectionPolicy::required_tags
#ModelSelectionPolicy::with_tags
fn ModelSelectionPolicy::with_tags(self : ModelSelectionPolicy, tags : Array[String]) -> ModelSelectionPolicy#ModelSelectionResult
pub struct ModelSelectionResult {
selected : ModelCatalogEntry?
evaluations : Array[ModelEvaluation]
fallback_used : Bool
reason : String
} derive(Debug)Result of a selection pass, including explainability for rejected models.
#ModelSelectionResult::evaluations
#ModelSelectionResult::fallback_used
#ModelSelectionResult::none
fn ModelSelectionResult::none(evaluations : Array[ModelEvaluation], reason : String) -> ModelSelectionResult#ModelSelectionResult::reason
#ModelSelectionResult::selected
fn ModelSelectionResult::selected(entry : ModelCatalogEntry, evaluations : Array[ModelEvaluation], fallback_used : Bool, reason : String) -> ModelSelectionResult#ModelSelectionResult::selected_entry
#ModelSelector
#ModelStep
#ModelStep::new
#NoiseEstimate
pub struct NoiseEstimate {
variance : Double
standard_deviation : Double
samples : Int
confidence : Double
} derive(Debug)Noise estimates inferred from paired truth/measurement samples.
#NoiseEstimate::standard_deviation
#NoiseSchedule
pub struct NoiseSchedule {
nominal : Double
minimum : Double
maximum : Double
growth : Double
decay : Double
factor : Double
stressed_steps : Int
}A slowly adapting process-noise schedule. It reacts to sustained large
innovations while decaying toward the nominal factor after recovery.
#NoiseSchedule::new
fn NoiseSchedule::new(nominal : Double, minimum : Double, maximum : Double, growth : Double, decay : Double) -> NoiseSchedule#NoiseSchedule::observe
#ObservationBuffer
A bounded packet queue. The oldest packet is dropped when capacity is
reached, which is safer than allowing a delayed sensor to exhaust memory.
#ObservationBuffer::newest
#ObservationBuffer::oldest
#ObservationBuffer::packets
#ObservationBuffer::push
#ObservationPacket
#ObservationPacket::covariance
#ObservationPacket::new
fn ObservationPacket::new(timestamp : Int, sensor : String, values : Array[Double], covariance : Matrix) -> ObservationPacket#ObservationPacket::values
#ObservationPacket::with_inflated_noise
fn ObservationPacket::with_inflated_noise(self : ObservationPacket, factor : Double) -> ObservationPacket#OperationalMonitor
pub struct OperationalMonitor {
samples : Int
accepted : Int
failures : Int
covariance_failures : Int
consecutive_failures : Int
worst_nis : Double
score : Double
warmup_samples : Int
failure_limit : Int
nis_limit : Double
}Rolling health monitor suitable for long-running sensor services.
#OperationalMonitor::accepted
#OperationalMonitor::consecutive_failures
#OperationalMonitor::covariance_failures
#OperationalMonitor::failures
#OperationalMonitor::new
fn OperationalMonitor::new(warmup_samples : Int, failure_limit : Int, nis_limit : Double) -> OperationalMonitor#OperationalMonitor::observe
fn OperationalMonitor::observe(self : OperationalMonitor, timestamp : Int, filter : KalmanND, result : UpdateResult) -> OperationalSnapshot#OperationalMonitor::worst_nis
#OperationalSnapshot
pub struct OperationalSnapshot {
timestamp : Int
result : UpdateResult
status : FilterStatus
score : Double
nis : Double
state : Array[Double]
covariance : Matrix
} derive(Debug)A point-in-time operational view. It is intentionally independent of a
concrete filter type so it can be exported by a telemetry adapter.
#OperationalSnapshot::covariance
#OperationalSnapshot::result
#OperationalSnapshot::score
#OperationalSnapshot::state
#OperationalSnapshot::status
#OperationalSnapshot::timestamp
#OutlierDetector
#OutlierDetector::observe
#OutlierDetector::outlier_count
#PacketQuality
pub struct PacketQuality {
sensor : String
report : DataQualityReport
accepted : Bool
reason : String
} derive(Debug)#PipelineEvent
pub struct PipelineEvent {
fusion : FusionEvent
lifecycle : TrackLifecycle
sensor_score : Double
rolling_mean : Double
rolling_variance : Double
} derive(Debug)End-to-end stream pipeline: preprocess packets, fuse a state estimate, and
maintain lifecycle/health metadata for production telemetry.
#PipelineEvent::rolling_variance
#PipelineReport
pub struct PipelineReport {
events : Int
accepted : Int
rejected : Int
missing : Int
final_lifecycle : TrackLifecycle
final_sensor_score : Double
} derive(Debug)#PipelineReport::final_lifecycle
#PipelineReport::final_sensor_score
#PolynomialBasis
A regularized polynomial basis description.
#PolynomialBasis::center
Return center.
#PolynomialBasis::degree
Return polynomial degree.
#PolynomialBasis::features
Evaluate the polynomial feature vector at a scalar input.
#PolynomialBasis::new
Construct a polynomial basis with a numerically stable center and scale.
#PolynomialBasis::scale
Return scale.
#Pose2D
#Pose3D
A rigid pose mapping local-frame points into a parent frame.
#Pose3D::compose
Compose this pose with a child pose.
#Pose3D::interpolate
Interpolate translation and orientation.
#Pose3D::is_finite
Return whether the pose contains finite values.
#Pose3D::new
Construct a pose.
#Pose3D::rotation
Return the rotation component.
#Pose3D::to_matrix
Convert the pose to a homogeneous 4x4 transform matrix.
#Pose3D::to_vector
Convert a pose to a compact vector [tx, ty, tz, qw, qx, qy, qz].
#Pose3D::transform_point
Transform a point from local to parent coordinates.
#Pose3D::transform_vector
Transform a direction without applying translation.
#Pose3D::translation
Return the translation component.
#Pose3DSeries
A bounded sequence of timestamped poses for calibration and replay.
#Pose3DSeries::capacity
Return the configured capacity.
#Pose3DSeries::clear
Remove all stored poses and rejection history.
#Pose3DSeries::duration
Return the timestamp span.
#Pose3DSeries::entries
Return a copy of stored timestamp/pose pairs.
#Pose3DSeries::first
Return the oldest entry.
#Pose3DSeries::last
Return the newest entry.
#Pose3DSeries::length
Return the number of stored poses.
#Pose3DSeries::new
Construct an empty pose series.
#Pose3DSeries::push
Append a pose when its timestamp is monotonic and its values are finite.
#Pose3DSeries::rejected
Return the number of rejected poses.
#Quaternion3D
A quaternion representing a three-dimensional orientation.
#Quaternion3D::add_quaternion
Add two quaternions component-wise for averaging.
#Quaternion3D::conjugate
Return the conjugate quaternion.
#Quaternion3D::dot
Dot product of quaternion components.
#Quaternion3D::inverse
Return the inverse quaternion, when it exists.
#Quaternion3D::is_finite
Return whether all components are finite.
#Quaternion3D::lerp
Interpolate quaternion components and renormalize. This avoids a
trigonometric dependency while remaining stable for telemetry smoothing.
#Quaternion3D::multiply
Hamilton product of two quaternions.
#Quaternion3D::new
Construct a quaternion from scalar and vector parts.
#Quaternion3D::norm
Return the quaternion norm.
#Quaternion3D::norm_squared
Return the squared quaternion norm.
#Quaternion3D::normalize
Normalize a quaternion, returning None for invalid input.
#Quaternion3D::rotate
Rotate a vector using this quaternion. Non-unit inputs are normalized.
#Quaternion3D::scale
Scale all quaternion components.
#Quaternion3D::to_matrix
Convert a quaternion to a 3x3 rotation matrix.
#RangeMeasurement
#RangeMeasurement::jacobian
#RangeMeasurement::new
fn RangeMeasurement::new(reference : Array[Double], value : Double, variance : Double) -> RangeMeasurement#RangeMeasurement::reference
#RangeMeasurement::residual
#RecursiveLeastSquares
A recursive least-squares estimator for slowly changing calibration.
#RecursiveLeastSquares::coefficients
Return current coefficients.
#RecursiveLeastSquares::covariance
Return parameter covariance.
#RecursiveLeastSquares::forgetting
Return forgetting factor.
#RecursiveLeastSquares::new
fn RecursiveLeastSquares::new(dimension : Int, initial_covariance : Double, forgetting : Double) -> RecursiveLeastSquaresConstruct a recursive least-squares estimator.
#RecursiveLeastSquares::predict
Predict one scalar response.
#RecursiveLeastSquares::rejected
Return rejected update count.
#RecursiveLeastSquares::reset
Reset parameters to zero with a supplied covariance scale.
#RecursiveLeastSquares::update
fn RecursiveLeastSquares::update(self : RecursiveLeastSquares, features : Array[Double], value : Double) -> Double?Update RLS with one observation and return the innovation.
#RecursiveLeastSquares::updates
Return update count.
#ReplayEvent
pub(all) enum ReplayEvent {
Predict(Int)
Measure(Int, Array[Double])
Missing(Int)
Restore(FilterCheckpoint)
} derive(Debug)A timestamped action that can be applied to a linear filter. Keeping the
action separate from the filter makes offline reproduction and incident
investigation deterministic: the same event stream produces the same
state stream.
#ReplayRecord
pub struct ReplayRecord {
timestamp : Int
result : UpdateResult
state : Array[Double]
covariance : Matrix
nis : Double
} derive(Debug)One durable observation of a replay step.
#ReplayRecord::new
fn ReplayRecord::new(timestamp : Int, result : UpdateResult, state : Array[Double], covariance : Matrix, nis : Double) -> ReplayRecord#ReplayReport
Counts and records accumulated by a replay session.
#ReplayReport::final_covariance
#ReplaySession
pub struct ReplaySession {
filter : KalmanND
trace : ReplayTrace
timestamp : Int
steps : Int
accepted : Int
rejected : Int
missing : Int
invalid : Int
}Stateful replay runner for KalmanND. A runner owns its filter so callers
can replay a log without mutating the production filter used elsewhere.
#ReplaySession::new
#ReplaySession::run
#ReplaySession::step
#ReplayTrace
An append-only, bounded replay ledger. The bounded mode is useful for
embedded applications where a diagnostic trail must not grow forever.
#ResidualAction
A robust residual policy used before a measurement enters a filter.
#ResidualPolicy
pub struct ResidualPolicy {
soft_limit : Double
hard_limit : Double
minimum_weight : Double
accepted : Int
downweighted : Int
rejected : Int
}#ResidualPolicy::classify
#ResidualPolicy::minimum_weight
#ResidualPolicy::new
fn ResidualPolicy::new(soft_limit : Double, hard_limit : Double, minimum_weight : Double) -> ResidualPolicy#RobustEstimate
A scalar robust estimate with diagnostics.
#RobustEstimate::converged
Return whether the location iteration converged.
#RobustEstimate::effective_samples
Return the effective sample size.
#RobustEstimate::iterations
Return the number of iterations performed.
#RobustEstimate::location
Return the estimated location.
#RobustEstimate::residuals
Return a copy of residuals.
#RobustEstimate::scale
Return the robust scale.
#RobustEstimate::weights
Return a copy of final weights.
#RobustEstimatorConfig
pub struct RobustEstimatorConfig {
loss : RobustLossKind
tuning : Double
iterations : Int
tolerance : Double
minimum_weight : Double
} derive(Debug)Configuration shared by robust location and regression estimators.
#RobustEstimatorConfig::iterations
Return the iteration budget.
#RobustEstimatorConfig::loss
Return the loss kind.
#RobustEstimatorConfig::minimum_weight
Return the minimum retained weight.
#RobustEstimatorConfig::new
fn RobustEstimatorConfig::new(loss : RobustLossKind, tuning : Double, iterations : Int, tolerance : Double, minimum_weight : Double) -> RobustEstimatorConfigConstruct a robust estimator configuration with safe defaults.
#RobustEstimatorConfig::tolerance
Return the convergence tolerance.
#RobustEstimatorConfig::tuning
Return the tuning constant.
#RobustLineFit
A robust straight-line fit y = intercept + slope * x.
#RobustLineFit::converged
Return convergence state.
#RobustLineFit::intercept
Return the fitted intercept.
#RobustLineFit::iterations
Return the number of line-fit iterations.
#RobustLineFit::predict
Predict a response from a robust line fit.
#RobustLineFit::residuals
Return a copy of line-fit residuals.
#RobustLineFit::scale
Return the residual scale.
#RobustLineFit::slope
Return the fitted slope.
#RobustLineFit::weighted_error
Compute a robust line's weighted residual sum of squares.
#RobustLineFit::weights
Return final line-fit weights.
#RobustLossKind
Loss functions used by robust estimators for contaminated sensor data.
#RobustResidualSummary
pub struct RobustResidualSummary {
count : Int
finite : Int
rejected : Int
mean : Double
median : Double
mad : Double
rms : Double
maximum : Double
positive : Int
negative : Int
} derive(Debug)A residual distribution summary useful for quality dashboards.
#RobustResidualSummary::count
Return residual count.
#RobustResidualSummary::finite
Return finite residual count.
#RobustResidualSummary::mad
Return residual MAD.
#RobustResidualSummary::maximum
Return maximum absolute residual.
#RobustResidualSummary::mean
Return residual mean.
#RobustResidualSummary::median
Return residual median.
#RobustResidualSummary::negative
Return negative residual count.
#RobustResidualSummary::positive
Return positive residual count.
#RobustResidualSummary::rejected
Return rejected/non-finite count.
#RobustResidualSummary::rms
Return residual RMS.
#RobustSample
A weighted scalar sample.
#RobustSample::new
Construct a weighted sample.
#RobustSample::value
Return the sample value.
#RobustSample::weight
Return the sample weight.
#RollingWindow
A bounded feature window for streaming sensor preprocessing.
#RunningStats
pub struct RunningStats {
count : Int
mean : Double
second_moment : Double
minimum : Double
maximum : Double
}Numerically stable streaming mean and variance using Welford's update.
#RunningStats::standard_deviation
#SafetyCheckResult
pub struct SafetyCheckResult {
status : SafetyCheckStatus
value : Double
margin : Double
violation : SafetyViolation?
} derive(Debug)#SafetyCheckResult::disabled
#SafetyCheckResult::safe
#SafetyCheckResult::status
#SafetyCheckResult::violated
fn SafetyCheckResult::violated(value : Double, margin : Double, violation : SafetyViolation) -> SafetyCheckResult#SafetyCheckResult::violation
#SafetyCheckStatus
#SafetyConstraint
pub struct SafetyConstraint {
name : String
kind : SafetyConstraintKind
threshold : Double
tolerance : Double
severity : Double
enabled : Bool
} derive(Debug)#SafetyConstraint::kind
#SafetyConstraint::new
fn SafetyConstraint::new(name : String, kind : SafetyConstraintKind, threshold : Double, tolerance : Double, severity : Double) -> SafetyConstraint#SafetyConstraint::set_enabled
#SafetyConstraintKind
A scalar or vector safety constraint applied to an estimated state.
#SafetyEnvelope
#SafetyEnvelope::acceleration_limit
#SafetyEnvelope::check_acceleration
fn SafetyEnvelope::check_acceleration(self : SafetyEnvelope, acceleration : Vec3D, timestamp : Int?) -> SafetyCheckResult#SafetyEnvelope::check_pose
fn SafetyEnvelope::check_pose(self : SafetyEnvelope, pose : Pose3D, velocity : Vec3D, covariance : Matrix, timestamp : Int?) -> Array[SafetyCheckResult]#SafetyEnvelope::check_position
fn SafetyEnvelope::check_position(self : SafetyEnvelope, position : Vec3D, timestamp : Int?) -> SafetyCheckResult#SafetyEnvelope::check_uncertainty
fn SafetyEnvelope::check_uncertainty(self : SafetyEnvelope, covariance : Matrix, timestamp : Int?) -> SafetyCheckResult#SafetyEnvelope::check_velocity
fn SafetyEnvelope::check_velocity(self : SafetyEnvelope, velocity : Vec3D, timestamp : Int?) -> SafetyCheckResult#SafetyEnvelope::new
fn SafetyEnvelope::new(name : String, position_min : Vec3D, position_max : Vec3D, velocity_limit : Double, acceleration_limit : Double, uncertainty_limit : Double) -> SafetyEnvelope#SafetyEnvelope::uncertainty_limit
#SafetyEnvelope::velocity_limit
#SafetyEnvelope::violation_rate
#SafetyViolation
pub struct SafetyViolation {
name : String
kind : SafetyConstraintKind
value : Double
threshold : Double
excess : Double
severity : Double
timestamp : Int?
} derive(Debug)#SafetyViolation::kind
#SafetyViolation::new
fn SafetyViolation::new(constraint : SafetyConstraint, value : Double, excess : Double, timestamp : Int?) -> SafetyViolation#ScalarCalibration
pub struct ScalarCalibration {
measurement : NoiseEstimate
process : NoiseEstimate
recommended_process_noise : Double
recommended_measurement_noise : Double
} derive(Debug)#ScalarCalibration::measurement
#ScalarCalibration::process
#ScalarCalibration::recommended_measurement_noise
#ScalarCalibration::recommended_process_noise
#SensorCalibrator
Estimate an affine offset from reference-aligned samples.
#SensorCalibrator::add
fn SensorCalibrator::add(self : SensorCalibrator, raw : Array[Double], reference : Array[Double]) -> Bool#SensorCalibrator::error_covariance
#SensorCalibrator::offset
#SensorCalibrator::transform
#SensorClock
pub struct SensorClock {
period : Int
last_timestamp : Int?
samples : Int
late : Int
early : Int
jitter : RunningStats
}Timestamp discipline and jitter statistics for an input channel.
#SensorClockFit
pub struct SensorClockFit {
offset : Double
drift : Double
reference : Int
residual_rms : Double
samples : Int
valid : Bool
} derive(Debug)A linear clock correction estimated from paired timestamps.
#SensorClockFit::correct
Correct a timestamp using this clock fit.
#SensorClockFit::drift
Return clock drift as a fractional rate.
#SensorClockFit::offset
Return clock offset.
#SensorClockFit::reference
Return reference timestamp.
#SensorClockFit::residual_rms
Return residual RMS.
#SensorClockFit::samples
Return pair count.
#SensorClockFit::valid
Return whether the fit is usable.
#SensorConfiguration
Static configuration for a sensor channel.
#SensorConfiguration::covariance
#SensorConfiguration::dimension
#SensorConfiguration::enabled
#SensorConfiguration::new
fn SensorConfiguration::new(name : String, dimension : Int, period : Int, timeout : Int, covariance : Matrix) -> SensorConfiguration#SensorConfiguration::set_enabled
#SensorConfiguration::timeout
#SensorConfiguration::with_covariance
fn SensorConfiguration::with_covariance(self : SensorConfiguration, covariance : Matrix) -> SensorConfiguration#SensorFusion
pub struct SensorFusion {
filter : KalmanND
policy : FusionPolicy
statistics : FusionStatistics
consecutive_missing : Int
}#SensorFusion::new
#SensorFusion::process
#SensorFusion::process_missing
fn SensorFusion::process_missing(self : SensorFusion, timestamp : Int, sensor : String) -> FusionEvent#SensorFusion::run
#SensorFusion::set_gate_threshold
#SensorHealth
pub struct SensorHealth {
name : String
score : Double
decay : Double
recovery : Double
minimum_score : Double
accepted : Int
rejected : Int
}Per-sensor health state. It can be used to down-weight or disable a sensor
before its failures destabilize a global track.
#SensorHealth::is_usable
#SensorHealth::new
#SensorHealth::observe
#SensorModelPair
A pair of models for position and velocity sensors sharing one state.
#SensorModelPair::constant_velocity
fn SensorModelPair::constant_velocity(dimensions : Int, dt : Double, acceleration_variance : Double, position_variance : Double, velocity_variance : Double) -> SensorModelPair#SensorPacketBuilder
pub struct SensorPacketBuilder {
configuration : SensorConfiguration
calibration : CalibrationTransform
built : Int
rejected : Int
}Builder for validated packets with a reusable calibration transform.
#SensorPacketBuilder::build
fn SensorPacketBuilder::build(self : SensorPacketBuilder, timestamp : Int, values : Array[Double]) -> ObservationPacket?#SensorPacketBuilder::configuration
#SensorPacketBuilder::new
#SensorPacketBuilder::rejected
#SensorPacketBuilder::set_calibration
fn SensorPacketBuilder::set_calibration(self : SensorPacketBuilder, calibration : CalibrationTransform) -> Bool#SensorPipeline
pub struct SensorPipeline {
fusion : SensorFusion
tracker : TrackManager
health : Map[String, SensorHealth]
windows : Map[String, RollingWindow]
window_capacity : Int
}#SensorPipeline::lifecycle
#SensorPipeline::new
fn SensorPipeline::new(fusion : SensorFusion, confirmation_hits : Int, deletion_misses : Int, window_capacity : Int) -> SensorPipeline#SensorPipeline::process
#SensorPipeline::process_missing
fn SensorPipeline::process_missing(self : SensorPipeline, timestamp : Int, sensor : String) -> PipelineEvent#SensorPipeline::run
fn SensorPipeline::run(self : SensorPipeline, packets : Array[ObservationPacket]) -> Array[PipelineEvent]#SensorPipeline::sensor_health
#SensorPipeline::window
#SensorSample
#SensorSample::new
fn SensorSample::new(timestamp : Int, truth : Array[Double], measurement : Array[Double], missing : Bool, outlier : Bool) -> SensorSample#SimulationResult
pub struct SimulationResult {
samples : Array[SensorSample]
truth : Array[Array[Double]]
estimates : Array[Array[Double]]
metrics : ErrorMetrics
} derive(Debug)#SimulationResult::estimates
#SimulationResult::metrics
#SimulationResult::samples
#SimulationResult::truth
#SmoothingResult
Result of a Rauch-Tung-Striebel backward pass.
#SmoothingResult::covariances
#SmoothingResult::states
#StateCandidate
pub struct StateCandidate {
name : String
state : Array[Double]
covariance : Matrix
weight : Double
result : UpdateResult
} derive(Debug)A weighted state candidate used to compare independent estimators.
#StateCandidate::new
fn StateCandidate::new(name : String, state : Array[Double], covariance : Matrix, weight : Double, result : UpdateResult) -> StateCandidate#StateGuard
pub struct StateGuard {
rules : Array[StateGuardRule]
reject_invalid : Bool
reject_excess : Double
checks : Int
rejected : Int
clipped : Int
} derive(Debug)A state sanitizer applies bounds while preserving untouched dimensions.
#StateGuard::check
#StateGuard::new
fn StateGuard::new(rules : Array[StateGuardRule], reject_invalid : Bool, reject_excess : Double) -> StateGuard#StateGuard::repair
#StateGuardIssue
pub struct StateGuardIssue {
index : Int
name : String
value : Double
projected : Double
excess : Double
status : StateGuardStatus
} derive(Debug)#StateGuardIssue::new
fn StateGuardIssue::new(rule : StateGuardRule, value : Double, projected : Double, status : StateGuardStatus) -> StateGuardIssue#StateGuardIssue::status
#StateGuardReport
pub struct StateGuardReport {
original : Array[Double]
repaired : Array[Double]
issues : Array[StateGuardIssue]
accepted : Bool
changed : Bool
score : Double
} derive(Debug)#StateGuardReport::issues
#StateGuardReport::new
fn StateGuardReport::new(original : Array[Double], repaired : Array[Double], issues : Array[StateGuardIssue], accepted : Bool) -> StateGuardReport#StateGuardReport::original
#StateGuardReport::repaired
#StateGuardRule
pub struct StateGuardRule {
index : Int
name : String
minimum : Double
maximum : Double
tolerance : Double
enabled : Bool
} derive(Debug)A named bound for one component of a filter state.
#StateGuardRule::contains
#StateGuardRule::new
fn StateGuardRule::new(index : Int, name : String, minimum : Double, maximum : Double, tolerance : Double) -> StateGuardRule#StateGuardRule::project
#StateGuardRule::set_enabled
#StateGuardStatus
#StreamCursor
pub struct StreamCursor {
next_sequence : Int
last_timestamp : Int?
accepted : Int
rejected : Int
duplicate : Int
out_of_order : Int
} derive(Debug)A cursor tracks consumption and supports replay-safe sequence checks.
#StreamCursor::accept
#StreamDecision
Operational decisions emitted by a stream processor.
#StreamRecord
pub struct StreamRecord {
timestamp : Int
value : Double
source : String
sequence : Int
valid : Bool
} derive(Debug)A timestamped scalar record accepted by the streaming runtime.
#StreamRecord::new
fn StreamRecord::new(timestamp : Int, value : Double, source : String, sequence : Int) -> StreamRecord#StreamRecord::with_value
#StreamRuntime
pub struct StreamRuntime {
window : StreamWindow
cursor : StreamCursor
max_queue : Int
queue : Array[StreamRecord]
processed : Int
dropped : Int
emitted : Int
backpressure : Int
} derive(Debug)A production-oriented scalar stream processor.
#StreamRuntime::emit_if_ready
#StreamRuntime::ingest
#StreamRuntime::new
fn StreamRuntime::new(spec : StreamWindowSpec, start_sequence : Int, max_queue : Int) -> StreamRuntime#StreamStatistics
pub struct StreamStatistics {
count : Int
mean : Double
variance : Double
minimum : Double
maximum : Double
first_timestamp : Int?
last_timestamp : Int?
slope : Double
valid : Bool
} derive(Debug)Aggregate statistics for a window, computed without retaining mutable state.
#StreamStatistics::first_timestamp
#StreamStatistics::last_timestamp
#StreamStatistics::standard_deviation
#StreamWindow
pub struct StreamWindow {
spec : StreamWindowSpec
records : Array[StreamRecord]
watermark : Int?
max_timestamp : Int?
late_count : Int
invalid_count : Int
evicted_count : Int
} derive(Debug)Event-time window with bounded memory and watermark accounting.
#StreamWindow::advance_watermark
#StreamWindow::contains_timestamp
#StreamWindow::push
Push a record, returning whether it participates in the active window.
#StreamWindowSpec
pub struct StreamWindowSpec {
width : Int
lateness : Int
capacity : Int
min_samples : Int
allow_out_of_order : Bool
} derive(Debug)Window semantics for event-time processing.
#StreamWindowSpec::allow_out_of_order
#StreamWindowSpec::min_samples
#StreamWindowSpec::new
fn StreamWindowSpec::new(width : Int, lateness : Int, capacity : Int, min_samples : Int) -> StreamWindowSpec#StreamWindowSpec::with_out_of_order
#Synchronizer
pub struct Synchronizer {
tolerance : Int
last_timestamp : Int?
accepted : Int
rejected : Int
}#TelemetrySample
pub struct TelemetrySample {
timestamp : Int
channel : String
value : Double
quality : Double
result : UpdateResult
} derive(Debug)A lightweight scalar telemetry record for dashboards and field logs.
#TelemetrySample::new
fn TelemetrySample::new(timestamp : Int, channel : String, value : Double, quality : Double, result : UpdateResult) -> TelemetrySample#TelemetrySeries
#TelemetrySeries::push
#TelemetrySeries::samples
#TelemetrySummary
pub struct TelemetrySummary {
samples : Int
accepted : Int
missing : Int
rejected : Int
mean : Double
variance : Double
quality : Double
status : FilterStatus
} derive(Debug)#TimedVector
A timestamped vector sample used by asynchronous sensor adapters.
#TimedVector::dimension
Return the vector dimension.
#TimedVector::is_valid
Return whether the sample is finite and non-empty.
#TimedVector::new
Construct a timestamped vector. The values are copied at the boundary.
#TimedVector::quality
Return the sample quality.
#TimedVector::scale
Scale all vector components.
#TimedVector::shift
Shift the timestamp by an integer offset.
#TimedVector::timestamp
Return the timestamp.
#TimedVector::values
Return a copy of the sample vector.
#TimedVector::with_quality
Replace the quality without changing the vector.
#TrackLedger
pub struct TrackLedger {
entries : Array[TrackLedgerEntry]
capacity : Int
miss_limit : Int
evictions : Int
} derive(Debug)A bounded in-memory registry for assignment results.
#TrackLedger::active_entries
#TrackLedger::inactive_entries
#TrackLedger::observe
fn TrackLedger::observe(self : TrackLedger, timestamp : Int, decisions : Array[AssociationDecision]) -> Unit#TrackLedgerEntry
pub struct TrackLedgerEntry {
id : Int
hits : Int
misses : Int
age : Int
score : Double
last_timestamp : Int?
last_measurement : Int?
active : Bool
} derive(Debug)A stable track identity with lifecycle counters and quality history.
#TrackLedgerEntry::last_measurement
#TrackLedgerEntry::last_timestamp
#TrackLedgerEntry::observe
fn TrackLedgerEntry::observe(self : TrackLedgerEntry, timestamp : Int, measurement_id : Int?, confidence : Double, miss_limit : Int) -> Unit#TrackLifecycle
Estimate lifecycle used by a tracker manager.
#TrackManager
pub struct TrackManager {
lifecycle : TrackLifecycle
confirmation_hits : Int
deletion_misses : Int
hits : Int
misses : Int
age : Int
}#TrackManager::new
#TrackManager::observe
#TrajectoryBuffer
Bounded trajectory history with monotonic timestamp protection.
#TrajectoryBuffer::first
#TrajectoryBuffer::points
#TrajectoryBuffer::push
#TrajectoryEvent
pub struct TrajectoryEvent {
timestamp : Int
flag : TrajectoryQualityFlag
severity : Double
index : Int
message : String
} derive(Debug)#TrajectoryEvent::flag
#TrajectoryEvent::new
fn TrajectoryEvent::new(timestamp : Int, flag : TrajectoryQualityFlag, severity : Double, index : Int, message : String) -> TrajectoryEvent#TrajectoryInterval
pub struct TrajectoryInterval {
start_timestamp : Int
end_timestamp : Int
duration : Double
displacement : Double
speed : Double
acceleration : Double
jerk : Double
valid : Bool
} derive(Debug)Kinematic statistics for one interval of a trajectory.
#TrajectoryInterval::acceleration
#TrajectoryInterval::displacement
#TrajectoryInterval::duration
#TrajectoryInterval::end_timestamp
#TrajectoryInterval::start_timestamp
#TrajectoryPoint
A timestamped state used by offline analysis and path-quality metrics.
#TrajectoryPoint::new
fn TrajectoryPoint::new(timestamp : Int, position : Array[Double], velocity : Array[Double], covariance : Matrix) -> TrajectoryPoint#TrajectoryPoint::position
#TrajectoryPoint::velocity
#TrajectoryQualityFlag
Quality flags emitted by trajectory validation.
#TrajectoryQualityReport
pub struct TrajectoryQualityReport {
point_count : Int
valid_points : Int
interval_count : Int
valid_intervals : Int
total_length : Double
duration : Int
mean_speed : Double
max_speed : Double
max_acceleration : Double
max_jerk : Double
mean_uncertainty : Double
score : Double
events : Array[TrajectoryEvent]
} derive(Debug)#TrajectoryQualityReport::duration
#TrajectoryQualityReport::events
#TrajectoryQualityReport::interval_count
#TrajectoryQualityReport::is_usable
#TrajectoryQualityReport::max_acceleration
#TrajectoryQualityReport::max_jerk
#TrajectoryQualityReport::max_speed
#TrajectoryQualityReport::mean_speed
#TrajectoryQualityReport::mean_uncertainty
#TrajectoryQualityReport::point_count
#TrajectoryQualityReport::score
#TrajectoryQualityReport::total_length
#TrajectoryQualityReport::valid_intervals
#TrajectoryQualityReport::valid_points
#TrajectorySegment
pub struct TrajectorySegment {
start_index : Int
end_index : Int
start_timestamp : Int
end_timestamp : Int
length : Double
mean_speed : Double
max_speed : Double
max_acceleration : Double
max_jerk : Double
mean_uncertainty : Double
quality : Double
valid : Bool
} derive(Debug)A contiguous segment annotated with kinematic and covariance quality.
#TrajectorySegment::end_timestamp
#TrajectorySegment::max_acceleration
#TrajectorySegment::max_jerk
#TrajectorySegment::max_speed
#TrajectorySegment::mean_speed
#TrajectorySegment::mean_uncertainty
#TrajectorySegment::start_index
#TrajectorySegment::start_timestamp
#UKF
pub struct UKF {
x : Array[Double]
p : Matrix
q : Matrix
r : Matrix
initial_state : Array[Double]
initial_covariance : Matrix
alpha : Double
beta : Double
kappa : Double
predicted_sigma_points : Array[Array[Double]]
last_innovation : Array[Double]
last_innovation_covariance : Matrix
last_gain : Matrix
last_nis : Double
gate_threshold : Double
predict_count : Int
accepted_count : Int
rejected_count : Int
missing_count : Int
}Unscented Kalman Filter using scaled sigma points.
UKF is useful when a model is smooth but its Jacobian is inconvenient to
derive. The implementation falls back to diagonal spread when a noisy
covariance is not Cholesky-decomposable, keeping an edge device alive
while diagnostics can report the covariance issue separately.
#UKF::filter
#UKF::new
#UKF::normalized_innovation_squared
#UKF::predict_with_control
#UKF::set_parameters
#UKF::update
#UKF::update_gated
#UncertaintyBox3D
An axis-aligned uncertainty region for a 3D position.
#UncertaintyBox3D::center
Return center.
#UncertaintyBox3D::confidence
Return confidence multiplier.
#UncertaintyBox3D::contains
Return whether a point is inside.
#UncertaintyBox3D::from_half_width
fn UncertaintyBox3D::from_half_width(center : Vec3D, half_width : Vec3D, confidence : Double) -> UncertaintyBox3DConstruct a 3D box directly from half widths.
#UncertaintyBox3D::half_width
Return half widths.
#UncertaintyBox3D::inflate
Inflate a box by a non-negative factor.
#UncertaintyBox3D::lower
Return lower corner.
#UncertaintyBox3D::new
fn UncertaintyBox3D::new(center : Vec3D, standard_deviations : Vec3D, multiplier : Double) -> UncertaintyBox3DConstruct a 3D uncertainty box from standard deviations.
#UncertaintyBox3D::upper
Return upper corner.
#UncertaintyBox3D::volume
Return volume.
#UncertaintyBudget
pub struct UncertaintyBudget {
contributions : Array[UncertaintyContribution]
total_variance : Double
total_standard_deviation : Double
} derive(Debug)An uncertainty budget accumulated from independent contributions.
#UncertaintyBudget::add
Add a contribution and recalculate fractions.
#UncertaintyBudget::clear
Remove all contributions.
#UncertaintyBudget::contributions
Return a copy of contributions.
#UncertaintyBudget::dominant
Return the largest active contribution.
#UncertaintyBudget::find
Return a budget contribution by name.
#UncertaintyBudget::new
Construct an empty budget.
#UncertaintyBudget::recalculate
Recalculate total variance and fractions.
#UncertaintyBudget::total_standard_deviation
Return total standard deviation.
#UncertaintyBudget::total_variance
Return total variance.
#UncertaintyContribution
pub struct UncertaintyContribution {
name : String
variance : Double
fraction : Double
enabled : Bool
} derive(Debug)A named uncertainty contribution for a budget review.
#UncertaintyContribution::enabled
Return enabled flag.
#UncertaintyContribution::fraction
Return normalized fraction.
#UncertaintyContribution::name
Return name.
#UncertaintyContribution::new
fn UncertaintyContribution::new(name : String, variance : Double, enabled : Bool) -> UncertaintyContributionConstruct a contribution.
#UncertaintyContribution::variance
Return variance.
#UpdateResult
Result of a measurement update.
#UpdateSummary
pub struct UpdateSummary {
result : UpdateResult
innovation : Array[Double]
innovation_covariance : Matrix
normalized_innovation_squared : Double
} derive(Debug)A compact record of the latest update, useful for telemetry and debugging.
#UpdateSummary::innovation_covariance
#ValidationReport
pub struct ValidationReport {
name : String
checks : Int
passed : Int
issues : Array[ContractIssue]
}#ValidationReport::check
fn ValidationReport::check(self : ValidationReport, code : String, condition : Bool, severity : ContractSeverity, message : String) -> Bool#ValidationReport::issues
#Vec3D
A finite three-dimensional vector used for sensor-frame and world-frame
calculations. The type is deliberately small and immutable from callers;
every arithmetic method returns a new value.
#Vec3D::clamp
Clamp each component to the same interval.
#Vec3D::distance
Return the distance between two points.
#Vec3D::hadamard
Multiply components pairwise.
#Vec3D::is_finite
Return whether all components are finite.
#Vec3D::lerp
Linearly interpolate two vectors.
#Vec3D::max_abs
Return the largest absolute component.
#Vec3D::new
Construct a three-dimensional vector.
#Vec3D::norm_squared
Return the squared Euclidean norm.
#Vec3D::normalize
Normalize the vector, returning None for a zero or non-finite vector.
#Vec3D::project
Project this vector onto a direction. A zero direction produces zero.
#Vec3D::reflect
Reflect a vector across a plane normal.
#Vec3D::reject
Remove the component parallel to a direction.
#Vec3D::to_array
Convert to an owned array in x/y/z order.
#VectorAccumulator
Online vector statistics using a numerically stable rank-one update.
#VectorAccumulator::add
#VectorAccumulator::covariance
#VectorAccumulator::standard_deviation
#VectorConfidenceBand
A component-wise confidence band for a vector state.
#VectorConfidenceBand::contains
Return whether a vector lies inside component-wise bounds.
#VectorConfidenceBand::dimension
Return state dimension.
#VectorConfidenceBand::estimates
Return estimates.
#VectorConfidenceBand::lower
Return lower bounds.
#VectorConfidenceBand::multiplier
Return multiplier.
#VectorConfidenceBand::new
fn VectorConfidenceBand::new(estimates : Array[Double], covariance : Matrix, multiplier : Double) -> VectorConfidenceBandConstruct a vector confidence band from a covariance diagonal.
#VectorConfidenceBand::standard_deviations
Return component deviations.
#VectorConfidenceBand::upper
Return upper bounds.
#VectorConfidenceBand::valid
Return validity.
#WeightedAccumulator
pub struct WeightedAccumulator {
dimension : Int
total_weight : Double
weighted_sum : Array[Double]
}A weighted mean useful for blending calibrated sensor channels.
#WeightedAccumulator::add
fn WeightedAccumulator::add(self : WeightedAccumulator, value : Array[Double], weight : Double) -> Bool#WeightedAccumulator::dimension
#WeightedAccumulator::mean
#WeightedAccumulator::weight
#acceleration_observation
Observe position, velocity, or both from a constant-acceleration state.
#align_timed_vectors
fn align_timed_vectors(samples : Array[TimedVector], timestamps : Array[Int], policy : AlignmentPolicy) -> (Array[AlignedVector], AlignmentReport)Align a series to an explicit timestamp grid.
#alignment_quality_score
fn alignment_quality_score(report : AlignmentReport, average_quality : Double, distance_limit : Int) -> DoubleCompute an alignment score combining coverage, quality, and distance.
#assess_packet
#assess_sensor_samples
#assess_trajectory_quality
fn assess_trajectory_quality(points : Array[TrajectoryPoint], max_gap : Int, max_speed_limit : Double, max_acceleration_limit : Double, max_jerk_limit : Double, uncertainty_limit : Double) -> TrajectoryQualityReport#associate_candidates
fn associate_candidates(track_ids : Array[Int], measurement_ids : Array[Int], candidates : Array[AssociationCandidate], config : AssociationConfig) -> AssociationBatchGreedy global assignment with deterministic tie breaking.
#associate_vectors
fn associate_vectors(track_ids : Array[Int], measurement_ids : Array[Int], predictions : Array[Array[Double]], observations : Array[Array[Double]], variances : Array[Double], config : AssociationConfig) -> AssociationBatch#association_batch_quality
Return a normalized quality score for a batch.
#association_candidate_from_vectors
fn association_candidate_from_vectors(track_id : Int, measurement_id : Int, expected : Array[Double], observed : Array[Double], variances : Array[Double], config : AssociationConfig) -> AssociationCandidate#association_candidate_summary
#association_confidence_margin
fn association_confidence_margin(best : AssociationCandidate, second : AssociationCandidate?) -> Double#association_euclidean_distance
Calculate a bounded Euclidean distance.
#association_gate_probability
fn association_gate_probability(distance : Double, threshold : Double) -> Double#association_likelihood
fn association_likelihood(distance : Double, scale : Double) -> DoubleConvert a distance into a soft likelihood.
#association_mahalanobis_distance
Calculate a diagonal Mahalanobis distance with safe variances.
#association_pairwise_candidates
fn association_pairwise_candidates(track_ids : Array[Int], measurement_ids : Array[Int], predictions : Array[Array[Double]], observations : Array[Array[Double]], variances : Array[Double], config : AssociationConfig) -> Array[AssociationCandidate]Build all pairwise candidates for vector-valued tracks.
#association_validate_ids
#attenuate_timed_vector_quality
fn attenuate_timed_vector_quality(samples : Array[TimedVector], reference : Int, time_constant : Double) -> Array[TimedVector]Return a stream with quality attenuated by timestamp distance from a
reference time. This is useful when delayed samples should be retained
but contribute less to a fusion policy.
#average_pose3d
Average a sequence of poses using translation averaging and quaternion
component averaging with sign correction.
#batch_design_matrix
fn batch_design_matrix(observations : Array[BatchObservation]) -> (Matrix, Array[Double], Array[Double])Build a design matrix from observations, retaining only consistent rows.
#batch_error_metrics
Compute RMSE and MAE.
#batch_feature_dimension
Infer the feature dimension from the first valid observation.
#batch_fit_is_usable
fn batch_fit_is_usable(fit : BatchFitResult, maximum_condition : Double, maximum_rmse : Double) -> BoolReturn whether a batch fit meets numerical quality limits.
#batch_fit_summary
Return a compact report line for a batch fit.
#batch_influence_scores
Return Cook-like influence scores from residuals and leverage.
#batch_leverage
Compute leverage values from a design matrix using a regularized inverse.
#batch_normal_equations
Form weighted normal equations X'WX and X'Wy.
#batch_polynomial_fit
fn batch_polynomial_fit(x : Array[Double], y : Array[Double], degree : Int, center : Double, scale : Double) -> BatchFitResultFit a polynomial model using normalized powers.
#batch_prediction_interval
fn batch_prediction_interval(fit : BatchFitResult, prediction : Double, confidence_scale : Double) -> (Double, Double)Return an interval around a predicted value.
#batch_prediction_radius
Compute a prediction interval radius from fit error and confidence scale.
#batch_predictions
Compute predictions from a design matrix and coefficient vector.
#batch_r_squared
Compute coefficient of determination.
#batch_residual_median
Compute a weighted residual median for regression diagnostics.
#batch_residuals
Compute residuals from design, observations, and coefficients.
#batch_robust_fit
fn batch_robust_fit(observations : Array[BatchObservation], config : RobustEstimatorConfig) -> BatchFitResultReturn a robust batch fit by iteratively updating observation weights.
#batch_weighted_least_squares
fn batch_weighted_least_squares(observations : Array[BatchObservation], regularization : Double) -> BatchFitResultSolve a weighted linear least-squares problem with diagonal regularization.
#batch_weighted_line_fit
fn batch_weighted_line_fit(x : Array[Double], y : Array[Double], weights : Array[Double]) -> BatchFitResultFit an intercept and one scalar feature.
#batch_weighted_mean_fit
Fit an intercept-only weighted model.
#calibrate_scalar
fn calibrate_scalar(measurements : Array[Double], expected : Array[Double], spacing : Double, minimum_noise : Double) -> ScalarCalibration#candidate_from_filter
fn candidate_from_filter(name : String, filter : KalmanND, result : UpdateResult, confidence : Double) -> StateCandidate#candidate_from_scalar
fn candidate_from_scalar(name : String, filter : Kalman1D, result : UpdateResult, confidence : Double) -> StateCandidate#check_safety_constraint
fn check_safety_constraint(constraint : SafetyConstraint, value : Double, timestamp : Int?) -> SafetyCheckResult#clamp_state_to_bounds
#classify_residual_vector
Apply a scalar policy to a residual vector. The smallest component weight
is used for the complete observation, which is conservative for correlated
sensors and avoids accidentally trusting a partially corrupted packet.
#clip_residual_vector
Apply symmetric clipping to a vector.
#combine_independent_estimates
fn combine_independent_estimates(estimates : Array[Double], variances : Array[Double]) -> ConfidenceBandCombine scalar estimates using inverse-variance weights.
#combine_independent_variances
Combine independent covariance estimates using precision weighting.
#combine_validation_reports
#compare_model_scores
#compare_uncertainty_covariances
Compare two covariance matrices by trace and condition.
#confidence_band_from_variance
fn confidence_band_from_variance(estimate : Double, variance : Double, multiplier : Double) -> ConfidenceBandConstruct a band from a variance.
#confidence_coverage
Return the fraction of a reference state covered by bands.
#confidence_coverage_score
Return a confidence level score from repeated truth coverage.
#constant_acceleration_process_noise
fn constant_acceleration_process_noise(dimensions : Int, dt : Double, jerk_variance : Double) -> Matrix#constant_acceleration_transition
Constant-acceleration transition for each independent axis. State order
is [position, velocity, acceleration] repeated by axis.
#constant_jerk_process_noise
#constant_jerk_transition
Constant-jerk model with state [position, velocity, acceleration, jerk]
per axis for highly dynamic motion.
#constant_velocity_model
fn constant_velocity_model(dimensions : Int, dt : Double, acceleration_variance : Double, measurement_variance : Double) -> LinearModelBuild a usable constant-velocity model for a position sensor.
#constant_velocity_process_noise
fn constant_velocity_process_noise(dimensions : Int, dt : Double, acceleration_variance : Double) -> MatrixWhite-acceleration process noise for the constant-velocity model.
#constant_velocity_transition
Constant-velocity transition for dimensions independent axes. State
order is [position_0..position_n, velocity_0..velocity_n].
#control_interpolate
fn control_interpolate(left : ControlCommand, right : ControlCommand, timestamp : Int) -> ControlCommand#correct_sensor_clock
Apply a clock fit to a timestamped series.
#correct_sensor_clock_values
fn correct_sensor_clock_values(samples : Array[TimedVector], fit : SensorClockFit) -> Array[TimedVector]Correct a series using the clock fit while retaining vector and quality.
#covariance_is_positive_definite
#covariance_is_psd
Return whether a matrix is symmetric positive semidefinite within a
caller-supplied tolerance.
#covariance_project_psd
#covariance_relative_change
#covariance_standard_deviations
Compute per-component standard deviations from covariance.
#covariance_to_markdown
#covariance_trace3d
Return the trace of a 3D covariance matrix.
#covariance_trace_decreased
Return whether a covariance update is monotonic in trace.
#covariance_uncertainty_score
Return a normalized uncertainty score where zero is best.
#deduplicate_timed_vectors
Remove duplicate timestamps, retaining the higher quality sample.
#detect_spikes
#diagnostic_covariance_health
#diagnostic_event_counts
#diagnostic_field_from_covariance
fn diagnostic_field_from_covariance(name : String, covariance : Matrix, unit : String) -> DiagnosticField#diagnostic_field_from_state
fn diagnostic_field_from_state(name : String, state : Array[Double], unit : String, index : Int, minimum : Double, maximum : Double) -> DiagnosticField#diagnostic_merge_reports
fn diagnostic_merge_reports(left : DiagnosticReport, right : DiagnosticReport, run_id : String) -> DiagnosticReport#diagnostic_report_from_quality
fn diagnostic_report_from_quality(run_id : String, timestamp : Int, report : TrajectoryQualityReport) -> DiagnosticReport#diagnostic_snapshot_from_filter
fn diagnostic_snapshot_from_filter(timestamp : Int, source : String, state : Array[Double], covariance : Matrix) -> DiagnosticSnapshot#diagnostic_snapshot_summary
#diagnostic_value_within
fn diagnostic_value_within(value : Double, minimum : Double, maximum : Double) -> Bool#diagonal_covariance3d
Build a diagonal covariance matrix from component standard deviations.
#diagonal_mahalanobis3d
Compute a Mahalanobis-like diagonal distance for a 3D residual.
#empty_batch_fit
Return a zero-valued failed fit.
#estimate_noise
#estimate_process_noise
#estimate_stream_lag
fn estimate_stream_lag(source : Array[TimedVector], reference : Array[TimedVector], candidate_lags : Array[Int], policy : AlignmentPolicy) -> IntEstimate a constant lag by minimizing nearest-neighbor squared error.
#estimates_to_csv
#evaluate_consistency
#evaluate_errors
#evaluate_polynomial
fn evaluate_polynomial(coefficients : Array[Double], x : Double, center : Double, scale : Double) -> DoubleEvaluate a fitted polynomial at x.
#exponential_smooth
#extract_features
#extrapolate_trajectory_point
Constant-acceleration extrapolation of one point.
#filter_quality_score
fn filter_quality_score(metrics : ErrorMetrics, rejected : Int, covariance_failures : Int) -> DoubleA simple score for comparing two filter runs. Lower is better; rejected
observations and covariance failures are penalized separately.
#filter_timed_vectors
fn filter_timed_vectors(samples : Array[TimedVector], minimum_quality : Double) -> Array[TimedVector]Return only valid samples above a quality threshold.
#fit_sensor_clock
fn fit_sensor_clock(local_timestamps : Array[Int], reference_timestamps : Array[Int]) -> SensorClockFitEstimate a linear clock correction from paired local and reference times.
#fit_time_series_trend
Fit a trend to a timestamped scalar stream.
#fuse_measurements
fn fuse_measurements(measurements : Array[FusionMeasurement], strategy : FusionStrategy, covariance_floor : Double) -> FusionResult#hampel_filter
#huber_clip_residual
fn huber_clip_residual(residual : Double, threshold : Double) -> DoubleApply a Huber-style clipping policy to a scalar residual.
#inflate_covariance3d
Inflate a covariance matrix by a non-negative factor.
#inflate_for_residual
fn inflate_for_residual(covariance : Matrix, residual : Array[Double], policy : ResidualPolicy) -> Matrix#interpolate_missing
#interpolate_timed_vectors
fn interpolate_timed_vectors(left : TimedVector, right : TimedVector, timestamp : Int) -> AlignedVectorInterpolate a vector between two samples.
#interpolate_trajectory_point
fn interpolate_trajectory_point(left : TrajectoryPoint, right : TrajectoryPoint, timestamp : Int) -> TrajectoryPointInterpolate a position between two timestamped points.
#inverse_transform_point3d
Apply the inverse pose to a parent-frame point.
#join_alignment_report
fn join_alignment_report(left : Array[TimedVector], right : Array[TimedVector], policy : AlignmentPolicy) -> AlignmentReportReturn an alignment report for a nearest-neighbor join.
#join_timed_vectors
fn join_timed_vectors(left : Array[TimedVector], right : Array[TimedVector], policy : AlignmentPolicy) -> Array[(Int, Array[Double], Array[Double], Double)]Join two streams at matching timestamps.
#make_constant_acceleration_state
#make_constant_velocity_state
Convert a position/velocity pair into a constant-velocity state vector.
#make_innovation_diagnostics
fn make_innovation_diagnostics(innovation : Array[Double], covariance : Matrix, gate_threshold : Double) -> InnovationDiagnostics#make_model_schedule
#make_replay_events
fn make_replay_events(start_timestamp : Int, count : Int, first_value : Double, velocity : Double, missing_period : Int) -> Array[ReplayEvent]Make a reproducible sequence of scalar observations with periodic drops.
This is intentionally small and deterministic so it is useful in examples,
acceptance tests, and regression tests without a random dependency.
#merge_timed_vector_streams
Merge multiple streams.
#merge_timed_vectors
Merge two timestamped streams and retain deterministic timestamp ordering.
#metrics_to_markdown
Produce a concise Markdown table suitable for a CI artifact or README.
#missing_action
#model_catalog_best_by_latency
#model_catalog_compatible
fn model_catalog_compatible(catalog : ModelCatalog, dimension : Int, tags : Array[String]) -> Array[ModelCatalogEntry]#model_catalog_has_regression
fn model_catalog_has_regression(baseline : ModelCatalogEntry, candidate : ModelCatalogEntry, tolerance : Double, higher_is_better : Bool) -> Bool#model_catalog_rank
fn model_catalog_rank(catalog : ModelCatalog, policy : ModelSelectionPolicy) -> Array[ModelEvaluation]#model_entry_preferred
fn model_entry_preferred(left : ModelCatalogEntry, right : ModelCatalogEntry, higher_is_better : Bool) -> BoolCompare two entries with a lexicographic score/latency policy.
#model_metric_regression_score
fn model_metric_regression_score(baseline : Double, candidate : Double, higher_is_better : Bool) -> Double#normalize_confidences
Return normalized weights for a set of positive confidence scores.
#packet_is_fresh
Decide whether a packet timestamp is still usable relative to a clock.
#permissive_alignment_policy
Return a permissive policy for embedded sensor streams.
#planar_range
Predict the Euclidean range of a Cartesian position and the corresponding
bearing-free residual used by a range-only sensor.
#planar_range_jacobian
#point_cloud_bounds3d
Compute the axis-aligned bounds of a point cloud.
#point_cloud_centroid3d
Compute the centroid of a finite point cloud.
#point_cloud_covariance3d
Compute the covariance matrix of a 3D point cloud.
#polynomial_observations
fn polynomial_observations(x : Array[Double], y : Array[Double], basis : PolynomialBasis) -> Array[BatchObservation]Construct polynomial observations from x/y samples.
#pose3d_from_matrix
Construct a pose from a homogeneous 4x4 transform matrix.
#pose3d_from_vector
Construct a pose from a seven-element vector.
#pose3d_series_interpolate
Interpolate a pose series at a timestamp. Extrapolation is not performed.
#pose3d_series_max_step
Compute the maximum translation step between adjacent poses.
#pose3d_series_mean_translation
Compute the average translation of a pose series.
#pose3d_series_quality
Return a stable scalar quality score for a pose series.
#position_observation
Observe only the position components of a constant-velocity state.
#predict_constant_acceleration
#predict_constant_velocity
#predict_time_series_trend
fn predict_time_series_trend(fit : BatchFitResult, origin : Int, timestamps : Array[Int]) -> Array[Double]Predict values on a timestamp grid from a time-series trend fit.
#project_point_to_plane3d
Project a point onto a plane defined by a point and a normal.
#propagate_diagonal_uncertainty
Propagate a diagonal covariance through a linear gain.
#proportional_control
fn proportional_control(state : Array[Double], target : Array[Double], gain : Double, limits : ControlLimits) -> Array[Double]Generate a control vector that moves a state toward a target under limits.
#quality_adjusted_covariance
fn quality_adjusted_covariance(covariance : Matrix, report : DataQualityReport, floor : Double) -> Matrix#quaternion3d_between
Build a quaternion that rotates one vector to another using a stable
half-way construction. Opposing vectors fall back to a deterministic axis.
#quaternion3d_from_matrix
Construct a quaternion from a 3x3 rotation matrix using the trace branch.
This is intended for matrices close to a proper rotation.
#quaternion3d_identity
Return the identity orientation.
#recursive_least_squares_fit
fn recursive_least_squares_fit(observations : Array[BatchObservation], initial_covariance : Double, forgetting : Double) -> RecursiveLeastSquaresFit RLS over a batch and return its final state.
#regular_timestamps
Build a regular timestamp grid.
#regularize_uncertainty_covariance
Return a covariance matrix regularized to a positive diagonal floor.
#relative_pose3d
Compute the relative pose from parent to child.
#resample_linear
#resample_timed_vectors
fn resample_timed_vectors(samples : Array[TimedVector], start : Int, end : Int, period : Int, policy : AlignmentPolicy) -> (Array[AlignedVector], AlignmentReport)Resample a stream on a regular grid and return both values and report.
#resample_trajectory
fn resample_trajectory(points : Array[TrajectoryPoint], timestamps : Array[Int]) -> Array[TrajectoryPoint]#retime_constant_velocity
Update a transition matrix in-place for a new sampling interval while
retaining its shape.
#robust_confidence_radius
Compute a robust confidence radius from residuals and a confidence scale.
#robust_covariance_factor
#robust_fusion
#robust_huber_config
A configuration tuned for Huber-style sensor rejection.
#robust_inlier_fraction
Return the fraction of samples whose robust weight is above a threshold.
#robust_line_fit
fn robust_line_fit(x : Array[Double], y : Array[Double], config : RobustEstimatorConfig) -> RobustLineFitFit a robust straight line with iteratively reweighted normal equations.
#robust_location
Estimate a robust location with iteratively reweighted means.
#robust_loss_value
Return the loss value for a standardized residual.
#robust_loss_weight
fn robust_loss_weight(kind : RobustLossKind, residual : Double, tuning : Double, minimum_weight : Double) -> DoubleReturn the iteratively reweighted least-squares weight.
#robust_mad
Compute the median absolute deviation around a location.
#robust_median
Compute the median of finite values.
#robust_quality_score
Compute a robust score in [0, 1] from residuals and a scale limit.
#robust_residual_variance
Compute a weighted covariance of scalar residuals.
#robust_reweight_rows
Down-weight an observation vector using one scalar residual per row.
#robust_scale_from_mad
fn robust_scale_from_mad(mad : Double) -> DoubleConvert MAD to a Gaussian-consistent standard deviation estimate.
#robust_tukey_config
A configuration tuned for strongly contaminated streams.
#robust_weight
fn robust_weight(residual : Double, tuning : Double) -> DoubleBounded residual reweighting for robust updates. The output can be used to
inflate measurement covariance before calling KalmanND::update.
#robust_weighted_location
fn robust_weighted_location(values : Array[Double], base_weights : Array[Double], config : RobustEstimatorConfig) -> RobustEstimateEstimate robust location using explicit base weights.
#robust_weighted_mean
Compute a weighted mean while ignoring invalid samples.
#robust_weighted_quantile
Compute a robust weighted quantile using sorted finite values.
#robust_weighted_scale
Estimate a robust scale from a weighted residual vector.
#robust_weighted_variance
Compute a weighted variance around a known location.
#robust_weights_for_residuals
fn robust_weights_for_residuals(residuals : Array[Double], config : RobustEstimatorConfig, scale : Double) -> Array[Double]Return robust weights for a residual vector.
#rts_smooth
Rauch-Tung-Striebel smoother for a linear model.
#run_constant_velocity_2d_simulation
fn run_constant_velocity_2d_simulation(steps : Int, dt : Double, measurement_noise : Double, missing_period : Int, outlier_period : Int, seed : Int) -> SimulationResultRun the ready-to-use tracker against a simulated two-dimensional stream.
#run_scalar_simulation
fn run_scalar_simulation(steps : Int, measurement_noise : Double, missing_period : Int, outlier_period : Int, seed : Int) -> SimulationResult#safety_check_all
fn safety_check_all(constraints : Array[SafetyConstraint], value : Double, timestamp : Int?) -> Array[SafetyCheckResult]#safety_constraint_is_tight
#safety_covariance_radius
#safety_distance_bound
fn safety_distance_bound(name : String, threshold : Double, tolerance : Double, severity : Double) -> SafetyConstraintConstruct an explicit distance-to-reference constraint.
#safety_distance_constraint
fn safety_distance_constraint(constraint : SafetyConstraint, point : Vec3D, reference : Vec3D, timestamp : Int?) -> SafetyCheckResult#safety_distance_to_envelope
#safety_inflate_position_bounds
#safety_mahalanobis_constraint
fn safety_mahalanobis_constraint(constraint : SafetyConstraint, error : Array[Double], covariance : Matrix, timestamp : Int?) -> SafetyCheckResult#safety_project_position
A conservative projection of a point onto an axis-aligned envelope.
#safety_timestamp_consistent
fn safety_timestamp_consistent(previous : Int?, current : Int) -> Bool#safety_worst_result
#score_model
fn score_model(name : String, residuals : Array[Array[Double]], parameter_count : Int, consistency : Double) -> ModelScoreCalculate common model-selection scores from residuals.
#shift_timed_vector_stream
Shift a stream by a measured lag.
#signal_correlation
#signal_difference
#signed_plane_distance3d
Return the signed distance from a point to a plane.
#simulate_constant_velocity_2d
fn simulate_constant_velocity_2d(steps : Int, dt : Double, initial_position : Array[Double], velocity : Array[Double], measurement_noise : Double, missing_period : Int, outlier_period : Int, seed : Int) -> Array[SensorSample]Generate a two-dimensional constant-velocity trajectory with repeatable
sensor noise, dropped packets, and occasional gross outliers.
#simulate_scalar_measurements
fn simulate_scalar_measurements(steps : Int, initial_value : Double, drift : Double, noise : Double, missing_period : Int, outlier_period : Int, seed : Int) -> Array[SensorSample]#smooth_with_missing
#sort_timed_vectors
Return a copy of a series sorted by timestamp using insertion sort.
#state_confidence_bands
fn state_confidence_bands(state : Array[Double], covariance : Matrix, multiplier : Double) -> Array[ConfidenceBand]Build component confidence bands from a state and covariance.
#state_guard_changed_indices
#state_guard_distance
#state_guard_from_covariance
fn state_guard_from_covariance(state : Array[Double], covariance : Matrix, multiplier : Double, minimum : Array[Double], maximum : Array[Double]) -> StateGuard#state_guard_merge_rules
fn state_guard_merge_rules(left : Array[StateGuardRule], right : Array[StateGuardRule]) -> Array[StateGuardRule]#state_guard_normalize_weights
#state_guard_rules_for_dimension
fn state_guard_rules_for_dimension(minimum : Array[Double], maximum : Array[Double], tolerance : Double) -> Array[StateGuardRule]#state_guard_validate_dimension
#state_guard_weighted_distance
#state_guard_worst_issue
#state_has_valid_uncertainty
#state_within_bounds
Check a state against component-wise bounds without mutating it.
#stream_health_score
#stream_outlier_fraction
fn stream_outlier_fraction(records : Array[StreamRecord], center : Double, scale : Double) -> Double#stream_records_between
fn stream_records_between(records : Array[StreamRecord], start : Int, end : Int) -> Array[StreamRecord]#stream_records_for_source
#stream_records_values
#stream_statistics_merge
#stream_window_statistics
#strict_alignment_policy
Return a strict policy for synchronized control loops.
#summarize_pipeline
#summarize_robust_residuals
Summarize a residual array while retaining explicit invalid counts.
#summarize_telemetry
#summarize_uncertainty_covariance
Summarize a covariance matrix with an absolute symmetry tolerance.
#telemetry_from_filter
fn telemetry_from_filter(timestamp : Int, channel : String, filter : Kalman1D, result : UpdateResult) -> TelemetrySample#telemetry_gap_count
#telemetry_is_usable
#telemetry_merge
fn telemetry_merge(left : Array[TelemetrySample], right : Array[TelemetrySample]) -> Array[TelemetrySample]#telemetry_outlier_count
#telemetry_quality_adjusted_value
#telemetry_quality_histogram
#telemetry_quality_weighted_mean
#telemetry_resample
fn telemetry_resample(samples : Array[TelemetrySample], timestamps : Array[Int]) -> Array[TelemetrySample]#telemetry_sample_count
#time_series_observations
fn time_series_observations(timestamps : Array[Int], values : Array[Double]) -> Array[BatchObservation]Build observations for a scalar time series with an intercept and time.
#timed_vector_covariance
Compute a covariance matrix for a timestamped vector stream.
#timed_vector_gaps
Return timestamp gaps larger than an expected period.
#timed_vector_grid
Return a regular grid that covers all valid samples.
#timed_vector_interpolate
fn timed_vector_interpolate(samples : Array[TimedVector], timestamp : Int, policy : AlignmentPolicy) -> AlignedVectorInterpolate a series without extrapolating outside its support.
#timed_vector_mean
Compute the average vector over finite samples.
#timed_vector_median_period
Return the median timestamp interval.
#timed_vector_nearest
fn timed_vector_nearest(samples : Array[TimedVector], timestamp : Int, policy : AlignmentPolicy) -> AlignedVectorFind the nearest sample to a timestamp.
#timed_vector_quality_drop
Return the maximum absolute quality drop in a stream.
#timed_vector_quality_fraction
Compute the fraction of a stream that meets a quality threshold.
#timed_vectors_are_monotonic
Return whether timestamps are monotonic.
#trajectory_accelerations
Approximate acceleration from adjacent velocity samples.
#trajectory_average_speed
#trajectory_average_velocity
#trajectory_consistency_score
#trajectory_detect_segments
#trajectory_event_counts
#trajectory_interval
fn trajectory_interval(previous : TrajectoryPoint, current : TrajectoryPoint, prior_speed : Double) -> TrajectoryInterval#trajectory_length
Arc length of a sequence of positions.
#trajectory_position_bounds
#trajectory_report_summary
#trajectory_segment
fn trajectory_segment(points : Array[TrajectoryPoint], start_index : Int, end_index : Int, max_speed_limit : Double, max_acceleration_limit : Double, max_jerk_limit : Double) -> TrajectorySegmentBuild an annotated segment and retain only valid monotonic intervals.
#trajectory_total_distance
#trajectory_turning_angles
#transform_point3d
Compute a rigid-body transform from a local vector and pose.
#transform_points3d
Transform an array of points without modifying the input.
#transformed_cloud_error3d
Compute the sum of squared point residuals after applying a pose.
#uncertainty_mahalanobis_radius
Compute the Mahalanobis radius using a covariance matrix.
#uncertainty_overconfidence
fn uncertainty_overconfidence(coverage : Double, target : Double, tolerance : Double) -> BoolEstimate whether an uncertainty report is overconfident.
#uncertainty_underconfidence
fn uncertainty_underconfidence(coverage : Double, target : Double, tolerance : Double) -> BoolEstimate whether an uncertainty report is too conservative.
#uncertainty_volume_proxy
Compute the state uncertainty volume proxy from a covariance determinant.
#valid_batch_observation_count
Return the number of valid observations.
#validate_matrix
fn validate_matrix(name : String, matrix : Matrix, expected_rows : Int, expected_cols : Int) -> ValidationReport#validate_packet
#validate_sensor_configuration
#validate_state
#validate_trajectory
#vec3d_from_array
Construct from the first three entries of an array.
#vec3d_max
Return the component-wise maximum.
#vec3d_min
Return the component-wise minimum.
#vec3d_splat
Return a vector with all components equal to value.
#vector_all_close
#vector_axpy
#vector_clamp
#vector_dot
Dot product with a safe length check.
#vector_hadamard
#vector_lerp
#vector_normalize
Normalize a vector. Zero vectors stay zero instead of producing NaNs.
#vector_project
#vector_quantile
Linear-interpolated quantile in the closed interval [0, 1].
#vector_replace_non_finite
#vector_to_csv
Convert a vector to one CSV row.
#vector_weighted_mean
#vector_weighted_variance
Source Files
- advanced_models.mbt
- batch_estimation.mbt
- calibration.mbt
- control_models.mbt
- coordinate_frames.mbt
- data_quality.mbt
- diagnostic_export.mbt
- diagnostics.mbt
- ekf.mbt
- estimator_ensemble.mbt
- filter_extensions.mbt
- fusion.mbt
- fusion_strategies.mbt
- kalman_1d.mbt
- kalman_nd.mbt
- linear_algebra_extra.mbt
- matrix_arithmetic.mbt
- matrix_decompose.mbt
- matrix_types.mbt
- metrics.mbt
- model_catalog.mbt
- model_selection.mbt
- models.mbt
- operational.mbt
- pipeline.mbt
- quality_control.mbt
- replay.mbt
- reporting.mbt
- robust_estimation.mbt
- safety_constraints.mbt
- sensor_alignment.mbt
- sensor_runtime.mbt
- signal_processing.mbt
- simulation.mbt
- smoother.mbt
- state_constraints.mbt
- statistics_extended.mbt
- streaming_runtime.mbt
- telemetry.mbt
- track_association.mbt
- trajectory_quality.mbt
- trajectory_tools.mbt
- ukf.mbt
- uncertainty_analysis.mbt
- validation.mbt
- vector_math.mbt
Production-ready MoonBit state estimation, smoothing, and sensor fusion library
kalmanfilterstate-spacesensor-fusionekfukfsmoothing
0.2.1
Apache-2.0
Updated 6 hours ago
5 downloads