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.0
Download zipAuthor
Version
0.2.0
License
Apache-2.0
Repository
Last updated
12 hours ago
Downloads
2
README#moon-kalman
moon-kalman 是面向 MoonBit 的状态空间、卡尔曼滤波和传感器融合库，参加的是 2026 年 8 月官方 MoonBit 黑客松验收项目。
- GitHub：Lyllyl789/moon-kalman
- GitLink：Lyllyl789/moon-kalman
- Mooncakes：Lyllyl789/moon-kalman
- 许可证：Apache-2.0
#能力范围
核心滤波器已经是可运行实现，不是接口存根：
- Kalman1D：标量预测、控制输入、缺失观测、NIS 门限、批处理和自适应过程噪声。
- KalmanND：稠密矩阵状态空间模型、Joseph 协方差更新、部分观测、NIS 门限、控制矩阵、检查点和恢复。
- EKF / UKF：非线性状态转移、雅可比或 sigma 点、缺失观测、门限和诊断统计。
- 线性代数：矩阵运算、LU/部分选主元求解、逆、Cholesky、QR、最小二乘、特征值和条件数估计。
- 传感器工程：多传感器融合、异常值降权、数据质量审计、时间同步、校准、健康监控、有限轨迹缓存和运行时遥测。
- 估计后处理：RTS 全平滑、固定时滞平滑、信号处理、误差/一致性指标、模型选择、估计器集成和确定性回放。
所有可变数组和矩阵的公开访问器都会返回副本；输入维度、非有限数、奇异创新协方差和缺失观测都有明确结果，不通过异常退出掩盖错误。
#最小示例
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=\{result}, state=\{filter.state()}, variance=\{filter.uncertainty()}")可直接运行仓库中的示例：
moon run examples/sensor_fusion#验证与基准
当前测试套件包含 120 个测试，覆盖矩阵边界、奇异/退化协方差、空输入、维度错误、非有限输入、门限拒绝、丢包、回放、运行时健康状态、轨迹和传感器运行时。生产 .mbt 源码规模超过 8,000 行，测试代码另行统计并持续扩充。
发布构建基准入口：
moon run --target native --release benchmarks基准使用确定性输入并打印校验和，完整三次运行记录见 benchmarks/RESULTS.md。基准不是理论峰值，而是在 Windows、AMD Ryzen 7 5800H、MoonBit stable 0.1.20260814 上实测的本地结果。
#CI 与发布
.github/workflows/test.yml 在 Ubuntu、macOS 和 Windows 上安装官方 stable 工具链，执行：
moon version --all
moon update
moon check --target all --deny-warn
moon test --target all --deny-warn
moon fmt && git diff --exit-code
moon info && git diff --exit-code另有 native 覆盖率测试和手动触发的 Mooncakes 发布 workflow。发布不把 token 写入仓库，CI 仅从 GitHub Actions secret 读取 MOONCAKES_TOKEN。
项目完成情况和逐项验收证据见 AUGUST_HACKATHON_ACCEPTANCE.md。
#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
#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
#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
#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
#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
#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#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
#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
#Pose2D
#RangeMeasurement
#RangeMeasurement::jacobian
#RangeMeasurement::new
fn RangeMeasurement::new(reference : Array[Double], value : Double, variance : Double) -> RangeMeasurement#RangeMeasurement::reference
#RangeMeasurement::residual
#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#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
#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.
#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#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)#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
#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
#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
#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
#VectorAccumulator
Online vector statistics using a numerically stable rank-one update.
#VectorAccumulator::add
#VectorAccumulator::covariance
#VectorAccumulator::standard_deviation
#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.
#assess_packet
#assess_sensor_samples
#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#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.
#combine_validation_reports
#compare_model_scores
#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#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_to_markdown
#detect_spikes
#estimate_noise
#estimate_process_noise
#estimates_to_csv
#evaluate_consistency
#evaluate_errors
#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.
#fuse_measurements
fn fuse_measurements(measurements : Array[FusionMeasurement], strategy : FusionStrategy, covariance_floor : Double) -> FusionResult#hampel_filter
#inflate_for_residual
fn inflate_for_residual(covariance : Matrix, residual : Array[Double], policy : ResidualPolicy) -> Matrix#interpolate_missing
#interpolate_trajectory_point
fn interpolate_trajectory_point(left : TrajectoryPoint, right : TrajectoryPoint, timestamp : Int) -> TrajectoryPointInterpolate a position between two timestamped points.
#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.
#metrics_to_markdown
Produce a concise Markdown table suitable for a CI artifact or README.
#missing_action
#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.
#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
#position_observation
Observe only the position components of a constant-velocity state.
#predict_constant_acceleration
#predict_constant_velocity
#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#resample_linear
#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_covariance_factor
#robust_fusion
#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.
#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#score_model
fn score_model(name : String, residuals : Array[Array[Double]], parameter_count : Int, consistency : Double) -> ModelScoreCalculate common model-selection scores from residuals.
#signal_correlation
#signal_difference
#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
#state_has_valid_uncertainty
#state_within_bounds
Check a state against component-wise bounds without mutating it.
#summarize_pipeline
#summarize_telemetry
#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
#trajectory_accelerations
Approximate acceleration from adjacent velocity samples.
#trajectory_average_speed
#trajectory_length
Arc length of a sequence of positions.
#trajectory_turning_angles
#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
#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
- calibration.mbt
- control_models.mbt
- data_quality.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_selection.mbt
- models.mbt
- operational.mbt
- pipeline.mbt
- quality_control.mbt
- replay.mbt
- reporting.mbt
- sensor_runtime.mbt
- signal_processing.mbt
- simulation.mbt
- smoother.mbt
- statistics_extended.mbt
- telemetry.mbt
- trajectory_tools.mbt
- ukf.mbt
- validation.mbt
- vector_math.mbt
Production-ready MoonBit state estimation, smoothing, and sensor fusion library
kalmanfilterstate-spacesensor-fusionekfukfsmoothing
0.2.0
Apache-2.0
Updated 12 hours ago
2 downloads