hrvkit
Heart Rate Variability (HRV) toolkit in MoonBit for recovery monitoring and training status analysis.
hrv
heart-rate-variability
health
sports-science
moon add zhzh12345678/hrvkit@0.3.0
Download zipAuthor
Version
0.3.0
License
Apache-2.0
Repository
Last updated
6 hours ago
Downloads
1
README#moonbit-hrvkit
moonbit-hrvkit is a pure MoonBit toolkit for analyzing RR-interval recordings and turning them into reproducible HRV, signal-quality, recovery, and longitudinal training features. It is designed for wearable-data pipelines, local command-line analysis, and small embedded services that need the same implementation across MoonBit targets.
The library is deterministic, does not require native FFI, and provides explicit quality metadata alongside numerical results. It is an engineering and research component; physiological outputs should be interpreted with an appropriate domain protocol and are not a substitute for clinical diagnosis.
#Project positioning
The package covers the complete path from a raw RR stream to an auditable analysis report:
- ingest and normalize wearable samples with duplicate, ordering, gap, and quality diagnostics;
- validate and clean intervals with removal or interpolation policies;
- calculate time-domain, geometric, frequency-domain, and nonlinear features;
- build longitudinal recovery, training-load, forecast, and what-if scenario views;
- apply transparent quality gates and explainable decision actions;
- export stable CSV/JSON-friendly reports, provenance events, and runtime measurements.
#Core capabilities
- RR validation with physiological bounds, non-finite detection, duplicate checks, gap candidates, and quality grades.
- Auditable cleaning with local-median and linear interpolation, artifact events, replacement confidence, and correction magnitude.
- Standard HRV metrics including mean RR/HR, SDNN, RMSSD, pNN20/pNN50, SDSD, CVNN, MAD, Poincaré descriptors, histogram geometry, and stress/vagal indices.
- Periodogram and Welch spectral analysis with VLF/LF/HF bands, ratios, entropy, centroid, edge frequency, respiratory peak estimation, and autocorrelation.
- Nonlinear descriptors including sample entropy, approximate entropy, DFA, recurrence rate, turning-point ratio, and histogram entropy.
- Morning baselines, readiness scores, sleep-recovery summaries, ambulatory activity segmentation, training-load summaries, and longitudinal session status.
- Wearable ingestion cursors, CSV protocol adapters, bounded telemetry storage, cohort percentiles, recovery forecasts, training scenarios, and quality-aware decision support.
- Streaming statistics, batch/cohort summaries, calibration, protocol compliance, paired recording comparison, feature tables, provenance audit trails, runtime budgets, and deterministic simulation fixtures.
- A small CLI for cleaning, metrics, trends, full reports, quality diagnostics, and repeatable benchmarks.
#Quick start
Install a current stable MoonBit toolchain, then verify the workspace:
moon version --all
moon update
moon fmt --check
moon check --deny-warn --target all
moon test --deny-warn --target nativeUse the library from MoonBit code through the package namespace zhzh12345678/hrvkit:
let config = @hrvkit.HrvConfig::default()
let (cleaned, quality) = @hrvkit.clean_rr_intervals(
[800.0, 802.0, 798.0, 2200.0, 801.0],
@hrvkit.InterpolateLocalMedian,
config,
)
let metrics = @hrvkit.calculate_metrics(cleaned, config, quality)
println(metrics.rmssd.to_string())#CLI
Run the executable with:
moon run --target native cmd/main -- [options]| Option | Values | Purpose |
|---|---|---|
| --action | clean, metrics, trends, report, quality, benchmark | Select the operation |
| --format | csv, json | Input and output encoding for the selected operation |
| --cleaning | remove, median, linear | Artifact correction policy |
| --sample-rate | positive number | Tachogram sample rate for reports and benchmarks |
| --repetitions | positive integer | Number of benchmark repetitions |
| --data | inline CSV or JSON | Input recording or morning-history data |
Examples:
# Calculate metrics from a JSON array and emit JSON.
moon run --target native cmd/main -- --action metrics --format json --data "[800,802,798,805,801]"
# Clean a CSV recording and emit CSV.
moon run --target native cmd/main -- --action clean --format csv --cleaning median --data "800,802,2200,798,801"
# Generate a complete analysis report.
moon run --target native cmd/main -- --action report --format json --sample-rate 4 --data "[800,802,798,805,801]"
# Run the deterministic benchmark workload.
moon run --target native --release cmd/main -- --action benchmark --format csv --repetitions 10 --sample-rate 4#Architecture
The repository keeps the public library in the root package and the executable in cmd/main.
hrvkit.mbt / indicators.mbt domain types and core HRV metrics
validation.mbt / cleaning*.mbt validation, artifact policy, and repair audit
statistics.mbt / time_domain*.mbt robust descriptive and time-domain features
frequency*.mbt / respiration.mbt spectral and respiratory features
nonlinear.mbt / advanced_indicators.mbt geometric and nonlinear features
pipeline.mbt / reporting*.mbt end-to-end reports and stable exports
readiness*.mbt / sleep*.mbt recovery, sleep, and training summaries
session*.mbt / streaming.mbt longitudinal and online analysis
wearable_pipeline.mbt normalized wearable ingestion and windows
protocol_adapters.mbt source-specific CSV dialect adaptation
training_load_plus.mbt load dose, ratios, monotony, and alerts
longitudinal_plus.mbt robust recovery baselines and trajectories
quality_pipeline.mbt staged quality gates and batch orchestration
decision_support.mbt explainable findings and action plans
forecast_plus.mbt / scenario*.mbt forecasts and what-if training plans
telemetry_store.mbt / cohort*.mbt bounded storage and quality-aware cohorts
reporting_plus.mbt / audit*.mbt structured reports and provenance events
runtime_diagnostics.mbt runtime aggregates and regression budgets
configuration_registry.mbt validated application profiles
batch.mbt / matrix.mbt cohort aggregation and feature computation
protocol*.mbt / calibration*.mbt reproducible recording and sensor handling
synthetic*.mbt / benchmarks.mbt deterministic fixtures and benchmark API
cmd/main/main.mbt command-line interfaceAll public data structures derive JSON traits where useful and carry quality or validity fields instead of silently discarding unusable input.
#Benchmark
The built-in benchmark uses a deterministic 256-sample resting RR fixture, runs the complete analysis pipeline, and repeats the workload ten times. A representative native release run produced:
samples=256, repetitions=10, feature_count=35
mean_rr=799.8931407352728, rmssd=2.368779541044154
total_power=14633.821047418522, quality_ratio=1The checked-in benchmark record contains the deterministic output, coverage summary, source-scale measurement, toolchain version, and six warm-cache CLI timings. The timing includes process startup and the cached native build, so it is an integration baseline rather than a hardware-independent claim. The current local measurement contains 20,006 physical production MoonBit lines (17,059 non-comment, non-blank code lines) and 265 passing tests.
moon run --target native --release cmd/main -- --action benchmark --format csv --repetitions 10 --sample-rate 4#Tests
The test suite covers empty inputs, singleton and constant series, malformed CSV/JSON, non-finite values, physiological boundaries, invalid sample rates, artifact bursts, short spectral windows, degenerate matrices, wearable duplicates and gaps, protocol failures, quality-gate rejection, forecast short history, telemetry retention, scenario bounds, audit provenance, configuration failures, calibration round trips, report serialization, cohort aggregation, and CLI-facing output shapes.
Run the portable local targets directly:
moon test --deny-warn --target wasm-gc
moon test --deny-warn --target nativeThe local acceptance run contains 265 tests; wasm, wasm-gc, JavaScript, and native targets pass. A native coverage run records 5,233/7,297 covered lines (71.71%). CI also runs the JavaScript target after installing Node.js explicitly.
#CI
.github/workflows/check.yml checks formatting, strict warnings, all MoonBit targets, generated interface information, native execution, coverage, and the 20,000-line production source-size guard on Ubuntu, macOS, and Windows. The workflow installs the current stable MoonBit toolchain and Node.js instead of relying on repository-local runtimes.
#License
Licensed under the Apache License 2.0.
#HrvParseError
Parser error representation.
#ActivityBlock
pub(all) struct ActivityBlock {
start_index : Int
end_index : Int
state : ActivityState
duration_seconds : Double
sample_count : Int
mean_hr : Double
mean_rr : Double
rmssd : Double
quality_ratio : Double
} derive(Eq, ToJson, Debug, FromJson)A contiguous activity block.
#ActivityState
Coarse activity state inferred from heart rate and movement.
#ActivityThresholds
Default heart-rate and movement thresholds.
#ActivityThresholds::default
Conservative thresholds for mixed wearable data.
#AmbulatorySample
One synchronized wearable observation.
#AmbulatorySummary
pub(all) struct AmbulatorySummary {
sample_count : Int
duration_seconds : Double
rest_seconds : Double
light_seconds : Double
moderate_seconds : Double
vigorous_seconds : Double
mean_hr : Double
mean_rr : Double
valid_ratio : Double
block_count : Int
dominant_state : ActivityState
hr_load : Double
temperature_mean : Double
} derive(Eq, ToJson, Debug, FromJson)Day-level ambulatory summary.
#AnalysisOptions
pub(all) struct AnalysisOptions {
cleaning_method : CleaningMethod
sample_rate_hz : Double
remove_trend : Bool
window_function : WindowFunction
segment_size : Int
segment_hop : Int
nonlinear_enabled : Bool
} derive(Eq, ToJson, Debug, FromJson)Options for the end-to-end HRV analysis pipeline.
#AnalysisOptions::default
Conservative defaults suitable for short wearable recordings.
#AnalysisReport
pub(all) struct AnalysisReport {
raw_count : Int
cleaned_intervals : Array[Double]
raw_validation : IntervalValidation
quality : QualityReport
metrics : HrvMetrics
distribution : DistributionStats
poincare : PoincareMetrics
geometric : GeometricMetrics
heart_rate : HeartRateSummary
frequency : FrequencyMetrics
nonlinear : NonlinearMetrics
segments : Array[SegmentSummary]
feature_vector : Array[Double]
} derive(Eq, ToJson, Debug, FromJson)Full report for a single RR recording.
#ApplicationConfig
pub(all) struct ApplicationConfig {
environment : ConfigurationEnvironment
hrv : HrvConfig
analysis : AnalysisOptions
ingest : WearableIngestConfig
gate : QualityGatePolicy
load : LoadModelConfig
forecast : ForecastConfig
subject_retention_days : Int
deterministic : Bool
} derive(Eq, ToJson, Debug, FromJson)#ArtifactCluster
A contiguous cluster of artifacts.
#ArtifactEvent
pub(all) struct ArtifactEvent {
index : Int
value : Double
kind : IntervalDisposition
replacement : Double
confidence : Double
left_neighbor : Double
right_neighbor : Double
} derive(Eq, ToJson, Debug, FromJson)One detected artifact with enough context for audit logs.
#ArtifactProfile
pub(all) struct ArtifactProfile {
sample_count : Int
flagged_count : Int
range_violations : Int
local_outliers : Int
sudden_jumps : Int
repeated_values : Int
missing_values : Int
artifact_ratio : Double
median_step : Double
mad_step : Double
flags : Array[QualityFlag]
} derive(Eq, ToJson, Debug, FromJson)Quality profile of an RR stream.
#ArtifactReason
Reason assigned to a suspicious sample.
#AuditEvent
pub(all) struct AuditEvent {
ordinal : Int
run_id : String
timestamp : String
kind : AuditEventKind
outcome : AuditOutcome
component : String
message : String
input_count : Int
output_count : Int
quality_score : Double
checksum : String
} derive(Eq, ToJson, Debug, FromJson)#AuditEventKind
Reproducibility and provenance records for application runs.
Audit events contain no credentials and are suitable for a local export or
a structured log sink supplied by the host application.
#AuditFilter
pub(all) struct AuditFilter {
run_id : String?
component : String?
kind : AuditEventKind?
outcome : AuditOutcome?
minimum_quality : Double
} derive(Eq, ToJson, Debug, FromJson)#AuditOutcome
#AuditSummary
pub(all) struct AuditSummary {
event_count : Int
success_count : Int
warning_count : Int
rejection_count : Int
error_count : Int
component_count : Int
mean_quality : Double
last_outcome : AuditOutcome
} derive(Eq, ToJson, Debug, FromJson)#AuditTrail
pub(all) struct AuditTrail {
run_id : String
started_at : String
finished_at : String
events : Array[AuditEvent]
outcome : AuditOutcome
input_checksum : String
output_checksum : String
feature_count : Int
} derive(Eq, ToJson, Debug, FromJson)#AuditTrail::append
fn AuditTrail::append(self : AuditTrail, kind : AuditEventKind, outcome : AuditOutcome, component : String, message : String, input_count : Int, output_count : Int, quality_score : Double, checksum : String, timestamp : String) -> Unit#AuditTrail::finish
fn AuditTrail::finish(self : AuditTrail, finished_at : String, output_checksum : String, feature_count : Int) -> Unit#AuditTrail::new
#BandPower
Power and normalized power for one band.
#BatchRecord
A record in a multi-athlete or multi-session batch.
#BenchmarkConfig
Deterministic benchmark configuration shared by local and CI runs.
#BenchmarkConfig::default
The default workload is large enough to exercise every major layer.
#BenchmarkSummary
Aggregate benchmark output that can be copied into a report.
#CalibrationReport
A calibration audit record.
#ChangePoint
A detected change point between two local windows.
#CleaningMethod
Cleaning methods for RR intervals.
#CleaningResult
pub(all) struct CleaningResult {
intervals : Array[Double]
quality : QualityReport
validation : IntervalValidation
events : Array[ArtifactEvent]
changed_count : Int
max_correction : Double
} derive(Eq, ToJson, Debug, FromJson)Result of an auditable cleaning pass.
#CohortComparison
#CohortComparisonSummary
pub(all) struct CohortComparisonSummary {
observations : Int
quality_eligible : Int
quality_ratio : Double
ranges : Array[CohortMetricRange]
comparisons : Array[CohortComparison]
feature_vector : Array[Double]
} derive(Eq, ToJson, Debug, FromJson)#CohortMetricRange
#CohortObservation
Privacy-friendly cohort comparison primitives.
The module accepts already de-identified observations and returns ranges,
ranks, and quality-aware flags without retaining personal identifiers.
#CohortRank
#CohortSummary
pub(all) struct CohortSummary {
record_count : Int
subject_count : Int
rmssd_mean : Double
rmssd_median : Double
rmssd_sd : Double
rmssd_q1 : Double
rmssd_q3 : Double
mean_hr : Double
mean_quality : Double
low_quality_count : Int
strongest_subject : String
weakest_subject : String
} derive(Eq, ToJson, Debug, FromJson)Cohort-level distribution and quality summary.
#ConfigIssue
#ConfigValidation
pub(all) struct ConfigValidation {
valid : Bool
issues : Array[ConfigIssue]
normalized : ApplicationConfig
} derive(Eq, ToJson, Debug, FromJson)#ConfigurationEnvironment
Validated application configuration profiles.
Keeping policy validation in the library prevents silently accepting
impossible windows or unsafe thresholds from CLI and service callers.
#DailyLoadLedger
pub(all) struct DailyLoadLedger {
date : String
entries : Array[TrainingLoadEntry]
doses : Array[LoadDose]
total_load : Double
effective_load : Double
duration_minutes : Double
session_count : Int
average_intensity : Double
quality_ratio : Double
recovery_cost : Double
high_intensity_minutes : Double
} derive(Eq, ToJson, Debug, FromJson)#DateParts
Calendar date used to validate morning measurement records.
#DecisionAction
#DecisionContext
pub(all) struct DecisionContext {
quality_report : QualityReport?
recovery_report : LongitudinalRecoveryReport?
load_plan : TrainingLoadPlan?
sleep_hours : Double
sleep_efficiency : Double
symptom_score : Double
user_goal : String
requested_intensity : Double
} derive(Eq, ToJson, Debug, FromJson)#DecisionDomain
#DecisionFinding
pub(all) struct DecisionFinding {
code : String
domain : DecisionDomain
severity : DecisionSeverity
title : String
evidence : String
observed : Double
reference : Double
confidence : Double
action : String
} derive(Eq, ToJson, Debug, FromJson)#DecisionPlan
pub(all) struct DecisionPlan {
score : Double
confidence : Double
level : DecisionSeverity
findings : Array[DecisionFinding]
actions : Array[DecisionAction]
headline : String
disclaimer : String
} derive(Eq, ToJson, Debug, FromJson)#DecisionSeverity
Explainable decision support built on HRV quality, recovery, and load data.
It intentionally emits findings and actions instead of opaque medical claims.
#DecisionThresholds
#DistributionStats
Descriptive statistics used by HRV reports and signal diagnostics.
#ExportDocument
Export document with version and provenance.
#ExportRow
One serializable result row.
#FeatureScaler
Feature scaling parameters learned from a reference set.
#FeatureTable
A deterministic feature table.
#FeatureTable::from_features
fn FeatureTable::from_features(features : Array[NamedFeature], schema_version : String) -> FeatureTableMake a table and count finite versus missing values.
#ForecastBacktest
#ForecastBundle
pub(all) struct ForecastBundle {
recovery : OperationalForecastResult
load : OperationalForecastResult
backtest : ForecastBacktest
recommendation : String
} derive(Eq, ToJson, Debug, FromJson)#ForecastConfig
#ForecastMethod
Deterministic recovery and workload forecasting primitives.
Forecasts are deliberately bounded and accompanied by holdout error so
consumers can show uncertainty rather than treating a point estimate as fact.
#ForecastPoint
pub(all) struct ForecastPoint {
step : Int
value : Double
lower : Double
upper : Double
confidence : Double
algorithm : ForecastMethod
} derive(Eq, ToJson, Debug, FromJson)#ForecastResult
A one-step or multi-step forecast with uncertainty metadata.
#FrequencyBandPower
Power accumulated in a named frequency band.
#FrequencyMetrics
pub(all) struct FrequencyMetrics {
sample_rate_hz : Double
total_power : Double
vlf : FrequencyBandPower
lf : FrequencyBandPower
hf : FrequencyBandPower
lf_hf_ratio : Double
spectral_centroid_hz : Double
spectral_entropy : Double
peak_frequency_hz : Double
spectrum : Array[SpectrumBin]
} derive(Eq, ToJson, Debug, FromJson)Frequency-domain HRV descriptors.
#GeometricMetrics
Geometric HRV descriptors derived from an RR histogram.
#HeartRateSummary
A compact set of heart-rate zones for training dashboards.
#HrvConfig
#HrvMetrics
pub(all) struct HrvMetrics {
mean_rr : Double
mean_hr : Double
sdnn : Double
rmssd : Double
pnn50 : Double
pnn_custom : Double
quality : QualityReport
} derive(Eq, ToJson, Debug, FromJson)Computed time-domain HRV metrics.
#HrvPipelineRun
pub(all) struct HrvPipelineRun {
run_id : String
report : AnalysisReport?
gate : QualityGateResult
stages : Array[PipelineStageTrace]
input_count : Int
accepted : Bool
feature_vector : Array[Double]
export_csv : String
} derive(Eq, ToJson, Debug, FromJson)#IngestCursor
A compact state for an incremental ingest loop.
#IngestCursor::feature_vector
Return a compact cursor feature vector.
#IngestCursor::finish
Mark a cursor complete and freeze further updates.
#IngestCursor::mean_quality
Return the mean quality observed by a cursor.
#IngestCursor::new
Create an empty cursor for a streaming adapter.
#IngestCursor::push
fn IngestCursor::push(self : IngestCursor, sample : WearableSample, config : WearableIngestConfig) -> IngestNotice?Add one sample to a cursor without retaining the raw stream.
#IngestNotice
pub(all) struct IngestNotice {
index : Int
code : String
message : String
severity : String
disposition : WearableSampleDisposition
} derive(Eq, ToJson, Debug, FromJson)An ingestion notice is machine-readable and suitable for audit logs.
#IntervalDisposition
Physiological interpretation of one RR interval.
#IntervalObservation
pub(all) struct IntervalObservation {
index : Int
value : Double
disposition : IntervalDisposition
distance_from_median : Double
} derive(Eq, ToJson, Debug, FromJson)Detailed observation retained by the validation report.
#IntervalValidation
Input validation summary for a raw RR series.
#LoadAlert
pub(all) struct LoadAlert {
date : String
level : LoadRiskLevel
code : String
title : String
explanation : String
observed : Double
threshold : Double
action : String
} derive(Eq, ToJson, Debug, FromJson)#LoadDose
pub(all) struct LoadDose {
duration_component : Double
cardiovascular_component : Double
perceived_effort_component : Double
distance_component : Double
elevation_component : Double
quality_weight : Double
raw_load : Double
effective_load : Double
intensity_score : Double
band : LoadIntensityBand
} derive(Eq, ToJson, Debug, FromJson)#LoadIntensityBand
A production-oriented training load ledger for longitudinal HRV workflows.
The module keeps raw session context, transparent dose components, and
conservative status labels together so downstream applications can explain
why a recommendation was produced.
#LoadModelConfig
pub(all) struct LoadModelConfig {
max_hr_bpm : Double
resting_hr_floor_bpm : Double
acute_window_days : Int
chronic_window_days : Int
easy_rpe : Double
hard_rpe : Double
quality_floor : Double
monotony_floor : Double
caution_ratio : Double
critical_ratio : Double
} derive(Eq, ToJson, Debug, FromJson)#LoadRiskLevel
#LongitudinalRecoveryReport
pub(all) struct LongitudinalRecoveryReport {
records : Array[RecoveryDayRecord]
assessments : Array[RecoveryDayAssessment]
baseline : RecoveryBaseline
trajectory : RecoveryTrajectory
current_score : Double
current_status : RecoveryDayStatus
missing_days : Int
quality_ratio : Double
stable_streak : Int
} derive(Eq, ToJson, Debug, FromJson)#MatrixShape
Matrix shape.
#MetricRow
A stable key/value row for human-readable metric exports.
#MorningAlert
An explainable alert emitted for a morning series.
#MorningBaselineState
Baseline state used by repeated morning measurements.
#MorningMeasurement
A single day's morning HRV measurement.
#MorningTrend
Computed morning baseline and trend analysis for a specific day.
#NamedFeature
One named numeric feature with provenance.
#NonlinearMetrics
Non-linear HRV descriptors for rhythm complexity and recurrence.
#NormalizedWearableSample
pub(all) struct NormalizedWearableSample {
sample : WearableSample
quality_weight : Double
disposition : WearableSampleDisposition
repaired : Bool
} derive(Eq, ToJson, Debug, FromJson)A normalized sample with a source-independent quality weight.
#OnlineStats
Online moments and extrema for long-running RR ingestion.
#OnlineStats::merge
Merge another accumulator using Chan's parallel moments formula.
#OnlineStats::push
Add one observation using Welford's stable update.
#OnlineStats::push_all
Add all observations in order.
#OnlineStats::snapshot
Return an immutable snapshot of the current accumulator.
#OnlineStats::standard_deviation
Return sample standard deviation from an online accumulator.
#OnlineStats::variance
Return sample variance from an online accumulator.
#OperationalForecastResult
pub(all) struct OperationalForecastResult {
algorithm : ForecastMethod
history_count : Int
points : Array[ForecastPoint]
baseline : Double
slope : Double
mean_absolute_error : Double
root_mean_squared_error : Double
coverage : Double
usable : Bool
} derive(Eq, ToJson, Debug, FromJson)#OperationalReport
#OperationalReportMetric
#OperationalReportSection
pub(all) struct OperationalReportSection {
kind : ReportSectionKind
title : String
summary : String
metrics : Array[OperationalReportMetric]
rows : Array[Array[String]]
warnings : Array[String]
} derive(Eq, ToJson, Debug, FromJson)#PipelineBatchSummary
#PipelineStageKind
Auditable orchestration for turning raw RR data into a usable decision.
Every stage has a status, duration supplied by the caller, and explicit
reasons so a dashboard can distinguish a failed gate from missing data.
#PipelineStageStatus
#PipelineStageTrace
pub(all) struct PipelineStageTrace {
ordinal : Int
kind : PipelineStageKind
status : PipelineStageStatus
input_count : Int
output_count : Int
quality : Double
duration_ms : Double
message : String
} derive(Eq, ToJson, Debug, FromJson)#PoincareMetrics
Poincare-plot descriptors of short-term and long-term variability.
#ProtocolAdapterConfig
pub(all) struct ProtocolAdapterConfig {
dialect : WearableProtocolDialect
delimiter : String
has_header : Bool
default_quality : Double
source_id : String
start_timestamp_seconds : Double
infer_heart_rate : Bool
infer_quality : Bool
} derive(Eq, ToJson, Debug, FromJson)#ProtocolAdapterNotice
#ProtocolAdapterResult
pub(all) struct ProtocolAdapterResult {
dialect : WearableProtocolDialect
mapping : ProtocolColumnMapping
samples : Array[WearableSample]
notices : Array[ProtocolAdapterNotice]
accepted_count : Int
rejected_count : Int
header : Array[String]
source_id : String
} derive(Eq, ToJson, Debug, FromJson)#ProtocolColumnMapping
pub(all) struct ProtocolColumnMapping {
timestamp_index : Int
rr_index : Int
heart_rate_index : Int
quality_index : Int
movement_index : Int
temperature_index : Int
timestamp_unit : ProtocolUnit
rr_unit : ProtocolUnit
quality_unit : ProtocolUnit
} derive(Eq, ToJson, Debug, FromJson)#ProtocolPlan
A complete operator protocol.
#ProtocolRunReport
Protocol completion report.
#ProtocolStep
A protocol step shown to an operator.
#ProtocolStepResult
Completion state for a protocol step.
#ProtocolUnit
#ProtocolValidation
Protocol validation result with actionable reasons.
#QualityDecision
pub(all) struct QualityDecision {
accepted : Bool
confidence : Double
reasons : Array[String]
recommended_method : CleaningMethod
validation : IntervalValidation
diagnostic : SignalDiagnostic
} derive(Eq, ToJson, Debug, FromJson)An explainable policy decision.
#QualityFlag
pub(all) struct QualityFlag {
index : Int
value : Double
reason : ArtifactReason
severity : Double
replacement : Double
} derive(Eq, ToJson, Debug, FromJson)One sample-level quality flag with a normalized severity.
#QualityGatePolicy
#QualityGateResult
#QualityPolicy
Policy thresholds for deciding whether a recording can be scored.
#QualityPolicy::daily_recovery
A balanced policy for daily recovery measurements.
#QualityReport
Signal quality and cleaning statistics report.
#RangePosition
Position of a value within a reference range.
#RateEpisode
A sustained heart-rate episode.
#ReadinessLevel
Readiness interpretation for daily recovery dashboards.
#ReadinessScore
pub(all) struct ReadinessScore {
score : Double
level : ReadinessLevel
baseline_z : Double
trend_component : Double
quality_component : Double
explanation : String
} derive(Eq, ToJson, Debug, FromJson)A bounded readiness score with explainable components.
#RecordingComparison
pub(all) struct RecordingComparison {
left_mean : Double
right_mean : Double
mean_delta : Double
left_rmssd : Double
right_rmssd : Double
rmssd_delta : Double
standardized_delta : Double
agreement_bias : Double
agreement_limits_lower : Double
agreement_limits_upper : Double
distance : Double
} derive(Eq, ToJson, Debug, FromJson)Paired comparison between two HRV recordings.
#RecordingProtocol
Recording protocol used to validate an analysis request.
#RecordingProtocol::morning
Short field protocol suitable for a morning readiness check.
#RecordingProtocol::resting
Standard resting protocol: five minutes, at least 300 intervals.
#RecoveryBaseline
#RecoveryDayAssessment
pub(all) struct RecoveryDayAssessment {
record : RecoveryDayRecord
baseline : RecoveryBaseline
rr_z : Double
rmssd_z : Double
heart_rate_z : Double
sleep_z : Double
readiness_score : Double
status : RecoveryDayStatus
confidence : Double
reasons : Array[String]
} derive(Eq, ToJson, Debug, FromJson)#RecoveryDayRecord
pub(all) struct RecoveryDayRecord {
date : String
mean_rr_ms : Double
rmssd_ms : Double
sdnn_ms : Double
resting_hr_bpm : Double
sleep_hours : Double
sleep_efficiency : Double
respiratory_rate : Double
training_load : Double
signal_quality : Double
source : String
missing : Bool
} derive(Eq, ToJson, Debug, FromJson)#RecoveryDayStatus
#RecoveryTrajectory
Longitudinal recovery records and robust baselines for real-world use.
Missing or low-quality mornings remain visible in the audit trail instead
of being silently converted into zero-valued physiology.
#RecoveryTrendPoint
pub(all) struct RecoveryTrendPoint {
date : String
score : Double
rmssd : Double
resting_hr : Double
load : Double
status : RecoveryDayStatus
} derive(Eq, ToJson, Debug, FromJson)#RecoveryWeekSummary
pub(all) struct RecoveryWeekSummary {
week_index : Int
start_date : String
end_date : String
record_count : Int
usable_count : Int
average_readiness : Double
minimum_readiness : Double
average_rmssd : Double
average_sleep_hours : Double
total_training_load : Double
quality_ratio : Double
missing_count : Int
trajectory : RecoveryTrajectory
} derive(Eq, ToJson, Debug, FromJson)#ReferenceRange
A reference range with a label and sample provenance.
#RegressionSummary
A least-squares trend fitted to an ordered sequence.
#ReportSectionKind
Structured operational reports for CLI output, dashboards, and archives.
Values remain machine-readable while headline text stays concise enough for
a coach or operator to act on.
#ReportTable
A tabular report that can be exported to CSV or rendered by a dashboard.
#RespirationConfig
Respiratory analysis configuration.
#RespirationConfig::default
Default adult resting respiration search range.
#RespirationSummary
Respiratory modulation summary.
#RobustBaseline
Robust baseline statistics for a sequence of morning RMSSD values.
#RollingLoadProfile
pub(all) struct RollingLoadProfile {
dates : Array[String]
daily_loads : Array[Double]
acute_load : Double
chronic_load : Double
acute_chronic_ratio : Double
exponentially_weighted_load : Double
monotony : Double
strain : Double
load_trend : Double
rest_day_count : Int
high_load_day_count : Int
} derive(Eq, ToJson, Debug, FromJson)#RuntimeAggregate
#RuntimeBudget
#RuntimeCheck
pub(all) struct RuntimeCheck {
aggregate : RuntimeAggregate
budget : RuntimeBudget
passed : Bool
reasons : Array[String]
} derive(Eq, ToJson, Debug, FromJson)#RuntimeReport
pub(all) struct RuntimeReport {
samples : Array[RuntimeSample]
aggregates : Array[RuntimeAggregate]
checks : Array[RuntimeCheck]
passed : Bool
feature_vector : Array[Double]
} derive(Eq, ToJson, Debug, FromJson)#RuntimeSample
Runtime diagnostics for reproducible local and CI performance checks.
Callers provide measured wall-clock values; this module summarizes them
without embedding machine-specific claims in the library.
#ScalarWindow
One scalar window observation.
#ScenarioComparison
pub(all) struct ScenarioComparison {
baseline : ScenarioResult
alternatives : Array[ScenarioResult]
recommended_index : Int
recommendation : String
} derive(Eq, ToJson, Debug, FromJson)#ScenarioConfig
#ScenarioResult
pub(all) struct ScenarioResult {
kind : TrainingScenarioKind
sessions : Array[ScenarioSession]
projected_load : Double
projected_ratio : Double
intensity_ceiling : Double
recovery_cost : Double
risk_score : Double
suitable : Bool
rationale : String
} derive(Eq, ToJson, Debug, FromJson)#ScenarioSession
#SegmentRange
A half-open index range in an RR stream.
#SegmentSummary
pub(all) struct SegmentSummary {
range : SegmentRange
count : Int
mean_rr : Double
sdnn : Double
rmssd : Double
pnn50 : Double
median_rr : Double
quality_ratio : Double
sd1 : Double
sd2 : Double
} derive(Eq, ToJson, Debug, FromJson)Metrics attached to one analysis segment.
#SensorCalibration
Sensor calibration parameters for vendor-neutral RR streams.
#SensorCalibration::identity
Return a neutral calibration profile.
#SensorCalibration::millisecond_sensor
Return a calibration profile for a common millisecond sensor feed.
#SessionAnalytics
pub(all) struct SessionAnalytics {
count : Int
usable_count : Int
mean_rmssd : Double
median_rmssd : Double
rmssd_trend : Double
rmssd_volatility : Double
mean_hr : Double
mean_quality : Double
total_load : Double
load_trend : Double
best_session_id : String
worst_session_id : String
} derive(Eq, ToJson, Debug, FromJson)Aggregated session analytics.
#SessionObservation
One analyzed session with quality metadata.
#SessionStatus
Per-session status relative to a rolling baseline.
#SignalDiagnostic
pub(all) struct SignalDiagnostic {
sample_count : Int
duration_seconds : Double
valid_ratio : Double
artifact_ratio : Double
mean_rr : Double
median_rr : Double
mean_hr : Double
hr_range : Double
rmssd : Double
sdnn : Double
drift_slope : Double
gap_candidates : Int
grade : String
} derive(Eq, ToJson, Debug, FromJson)A numeric diagnostic for a recording and its clean-up result.
#SignalQualityComponents
Quality components on a common zero-to-one scale.
#SignalQualitySummary
Weighted quality score and decision.
#SignalQualityWeights
Quality-score weights.
#SignalQualityWeights::default
Balanced default weights for daily RR data.
#SimulationConfig
pub(all) struct SimulationConfig {
length : Int
baseline_rr : Double
variability_ms : Double
sample_rate_hz : Double
scenario : SimulationScenario
artifact_period : Int
} derive(Eq, ToJson, Debug, FromJson)Simulation parameters.
#SimulationConfig::default
Default deterministic simulation configuration.
#SimulationScenario
Scenario type for synthetic RR data.
#SleepEpoch
pub(all) struct SleepEpoch {
start_minute : Double
duration_minutes : Double
stage : SleepStage
mean_rr : Double
rmssd : Double
quality_ratio : Double
} derive(Eq, ToJson, Debug, FromJson)One scored sleep epoch.
#SleepRecoverySummary
pub(all) struct SleepRecoverySummary {
total_minutes : Double
asleep_minutes : Double
awake_minutes : Double
deep_minutes : Double
rem_minutes : Double
light_minutes : Double
sleep_efficiency : Double
stage_transition_count : Int
overnight_mean_rr : Double
overnight_rmssd : Double
overnight_quality : Double
recovery_delta : Double
fragmentation_index : Double
} derive(Eq, ToJson, Debug, FromJson)Overnight recovery summary.
#SleepStage
Coarse sleep stage labels suitable for wearable summaries.
#SpectralBand
Named power-band definition.
#SpectralProfile
Spectral profile over a set of bands.
#SpectrumBin
One-sided periodogram bin.
#StreamingSession
pub(all) struct StreamingSession {
stats : OnlineStats
intervals : Array[Double]
config : HrvConfig
started : Bool
finished : Bool
} derive(Debug)Streaming recording state for incremental RR ingestion.
#StreamingSession::finish
Mark a session finished; later pushes are ignored.
#StreamingSession::is_usable
Return whether the session is ready for recovery scoring.
#StreamingSession::last
Return the latest interval, or zero before the first sample.
#StreamingSession::length
Return the current sample count.
#StreamingSession::mean
Return the current online mean without materializing a report.
#StreamingSession::new
Create an empty streaming session.
#StreamingSession::push
Ingest one RR interval and update the online moments.
#StreamingSession::push_all
Ingest a sequence of RR intervals.
#StreamingSession::reset
Reset a session while retaining its configuration.
#StreamingSession::snapshot
Return a snapshot without changing the session.
#StreamingSnapshot
pub(all) struct StreamingSnapshot {
metrics : HrvMetrics
validation : IntervalValidation
diagnostic : SignalDiagnostic
sample_count : Int
duration_seconds : Double
finished : Bool
} derive(Eq, ToJson, Debug, FromJson)A finished streaming session snapshot.
#SubjectSummary
Subject-specific aggregate used in cohort comparison.
#Tachogram
A uniformly sampled tachogram used by spectral analysis.
#TelemetryQuery
#TelemetryRecord
A dependency-free in-memory telemetry store for CLI tools, tests, and
embedded applications. It provides deduplication, bounded retention,
deterministic queries, and stable export without pretending to be a DB.
#TelemetryRetentionResult
#TelemetryStore
pub(all) struct TelemetryStore {
records : Array[TelemetryRecord]
notices : Array[TelemetryStoreNotice]
policy : TelemetryStorePolicy
} derive(Debug)#TelemetryStore::apply_retention
fn TelemetryStore::apply_retention(self : TelemetryStore, newest_timestamp : Double) -> TelemetryRetentionResult#TelemetryStore::enforce_limits
#TelemetryStore::insert
#TelemetryStore::insert_many
#TelemetryStore::notices
#TelemetryStore::query
#TelemetryStore::records
#TelemetryStore::retain_after
fn TelemetryStore::retain_after(self : TelemetryStore, cutoff_seconds : Double) -> TelemetryRetentionResult#TelemetryStoreNotice
#TelemetryStorePolicy
#TelemetrySummary
pub(all) struct TelemetrySummary {
record_count : Int
subject_count : Int
source_count : Int
first_timestamp : Double
last_timestamp : Double
duration_seconds : Double
mean_rr_ms : Double
mean_heart_rate_bpm : Double
mean_quality : Double
low_quality_count : Int
duplicate_notice_count : Int
} derive(Eq, ToJson, Debug, FromJson)#TelemetryWindow
A fixed-width time window over accepted telemetry.
#TimeDomainExtended
pub(all) struct TimeDomainExtended {
mean_rr : Double
mean_hr : Double
sdnn : Double
rmssd : Double
sdsd : Double
cvnn : Double
pnn20 : Double
pnn50 : Double
median_rr : Double
iqr_rr : Double
min_rr : Double
max_rr : Double
range_rr : Double
mad_rr : Double
triangular_index : Double
} derive(Eq, ToJson, Debug, FromJson)Extended time-domain feature set.
#TrainingDaySummary
Daily training and recovery aggregates.
#TrainingLoadEntry
pub(all) struct TrainingLoadEntry {
date : String
session_id : String
duration_minutes : Double
average_hr_bpm : Double
maximum_hr_bpm : Double
resting_hr_bpm : Double
rpe : Double
distance_km : Double
elevation_m : Double
signal_quality : Double
band : LoadIntensityBand
} derive(Eq, ToJson, Debug, FromJson)#TrainingLoadPlan
pub(all) struct TrainingLoadPlan {
days : Array[DailyLoadLedger]
profile : RollingLoadProfile
alerts : Array[LoadAlert]
total_load : Double
total_effective_load : Double
average_session_load : Double
peak_day : String
recommended_easy_days : Int
} derive(Eq, ToJson, Debug, FromJson)#TrainingLoadSummary
Daily training load summary using session duration and intensity.
#TrainingPlanMetrics
Longitudinal training-load indicators.
#TrainingScenarioKind
What-if planning for recovery-aware training decisions.
Scenarios are deterministic transformations of a baseline plan and never
mutate the caller's sessions, which makes them safe for UI previews.
#TrendDecomposition
Trend decomposition components.
#WearableIngestConfig
Ingestion settings shared by batch and streaming adapters.
#WearableIngestConfig::default
Conservative defaults for wearable telemetry.
#WearableIngestReport
pub(all) struct WearableIngestReport {
samples : Array[WearableSample]
notices : Array[IngestNotice]
accepted_count : Int
rejected_count : Int
duplicate_count : Int
out_of_order_count : Int
low_quality_count : Int
invalid_count : Int
gap_count : Int
duration_seconds : Double
quality_ratio : Double
complete : Bool
} derive(Eq, ToJson, Debug, FromJson)A stable summary returned by every ingestion operation.
#WearableProtocolDialect
CSV protocol adapters for common wearable exports.
The adapter layer separates source-specific column names and units from
the source-independent WearableSample and ingestion pipeline.
#WearableSample
A source-neutral sample emitted by a wearable or an offline recorder.
The type deliberately keeps the original timestamp and sensor metadata so
downstream reports can explain how a metric was produced. A sample may
carry both an RR interval and a heart-rate value; the ingestion layer
reconciles them without silently discarding the source values.
#WearableSampleDisposition
Disposition of a sample after validation.
#WindowFunction
Window functions for periodogram input.
#WindowSchedule
Window schedule.
#WindowSchedule::default
Default overlapping schedule for display metrics.
#WindowedAnalysis
A rolling analysis window with quality and headline metrics.
#WorkoutSession
A training session aligned with a morning recovery measurement.
#absolute_successive_differences
Return absolute successive changes, useful for artifact dashboards.
#activity_state_weight
Return a numeric load weight for an activity state.
#acute_chronic_workout_ratio
Calculate a seven-day load ratio from a session list.
#add_feature
Add a derived feature to a table.
#advanced_feature_vector
Return a robust HRV feature vector for downstream scoring.
#aggregate_runtime_samples
fn aggregate_runtime_samples(samples : Array[RuntimeSample], case_name : String, target : String) -> RuntimeAggregate#agreement_rate
Calculate the proportion of paired values within a tolerance.
#ambulatory_activity_load
Calculate a weighted activity load from blocks.
#ambulatory_feature_vector
Return a state-duration feature vector.
#ambulatory_summary_is_usable
Return whether an ambulatory summary has enough usable signal.
#analysis_export_document
Create a document for a report.
#analysis_export_rows
Convert an analysis report to a stable row set.
#analysis_preview
Return the first n cleaned intervals for preview cards.
#analysis_quality_summary
Return a short human-readable quality summary.
#analysis_report_markdown
Export a report as a Markdown table.
#analysis_report_markdown_with_quality
Create a Markdown report with the quality summary and feature vector size.
#analyze_rr
fn analyze_rr(intervals : Array[Double], config : HrvConfig, options : AnalysisOptions) -> AnalysisReportAnalyze an RR sequence through cleaning, quality, time, frequency, and
non-linear layers.
#analyze_rr_default
Analyze using the package defaults.
#analyze_streams
Analyze a batch as a set of independent streaming sessions.
#analyze_windows
fn analyze_windows(intervals : Array[Double], window_size : Int, hop_size : Int, config : HrvConfig) -> Array[WindowedAnalysis]Analyze overlapping windows without computing expensive spectral features.
#application_config_for
#apply_window
Apply a window without changing the input array.
#artifact_feature_vector
Create a stable artifact feature vector for model input.
#artifact_quality_score
Calculate a quality score that penalizes severe and repeated artifacts.
#artifact_runs
Group contiguous flags into artifact runs.
#assess_recovery_day
fn assess_recovery_day(record : RecoveryDayRecord, baseline : RecoveryBaseline) -> RecoveryDayAssessment#audit_calibration
Calculate the audit report for one calibration pass.
#audit_event_for_component
#audit_quality_floor_events
#audit_query
#autocorrelation
Autocorrelation at a lag, normalized by zero-lag energy.
#average_stream_rmssd
Return the average RMSSD across non-empty snapshots.
#average_window_readiness
Return the average recovery proxy across windows.
#baevsky_stress_index
Calculate a stress index based on histogram mode and spread.
#band_power_ratio
Calculate a band power ratio with a safe zero denominator.
#baseline_state
fn baseline_state(history : Array[MorningMeasurement], today_index : Int, config : HrvConfig) -> MorningBaselineStateBuild a baseline state from the historical values before today.
#batch_quality_decision
Combine policy decisions from a batch conservatively.
#benchmark_csv
Export benchmark values as a single CSV row.
#benchmark_input
Generate the deterministic workload for a benchmark run.
#benchmark_is_valid
Return whether a benchmark summary has usable output.
#best_scalar_window
Return the best window by a scalar field.
#best_telemetry_window
Return the window with the strongest quality-weighted sample count.
#best_window
Return the window with the highest readiness proxy.
#block_for_index
Find the contiguous block containing an index.
#bpm_to_rr
fn bpm_to_rr(rate_bpm : Double) -> DoubleConvert beats per minute into milliseconds per beat.
#bucket_window_means
Downsample window means into a fixed number of buckets.
#build_cohort_summary
fn build_cohort_summary(observations : Array[CohortObservation], quality_floor : Double) -> CohortComparisonSummary#build_decision_plan
#build_forecast_bundle
fn build_forecast_bundle(recovery_scores : Array[Double], load_values : Array[Double], config : ForecastConfig) -> ForecastBundle#build_longitudinal_recovery_report
fn build_longitudinal_recovery_report(records : Array[RecoveryDayRecord], baseline_window : Int) -> LongitudinalRecoveryReport#build_operational_report
fn build_operational_report(report_id : String, generated_at : String, subject_id : String, analysis : AnalysisReport?, gate : QualityGateResult, recovery : LongitudinalRecoveryReport?, training : TrainingLoadPlan?, forecast : ForecastBundle?, decision : DecisionPlan?) -> OperationalReport#build_recovery_baseline
#build_report_table
Build a table from a headline analysis report.
#build_rolling_load_profile
fn build_rolling_load_profile(days : Array[DailyLoadLedger], config : LoadModelConfig) -> RollingLoadProfile#build_runtime_report
fn build_runtime_report(samples : Array[RuntimeSample], budgets : Array[RuntimeBudget]) -> RuntimeReport#build_training_load_plan
fn build_training_load_plan(entries : Array[TrainingLoadEntry], config : LoadModelConfig) -> TrainingLoadPlan#calculate_approximate_entropy
fn calculate_approximate_entropy(values : Array[Double], dimension : Int, tolerance : Double) -> DoubleCalculate approximate entropy with self-matches included.
#calculate_band_powers
fn calculate_band_powers(spectrum : Array[SpectrumBin], bands : Array[SpectralBand]) -> Array[BandPower]Calculate all named band powers and relative contributions.
#calculate_cvnn
Calculate coefficient of variation of NN intervals in percent.
#calculate_dfa_alpha
Calculate a compact detrended fluctuation analysis exponent.
#calculate_fragmentation_index
Calculate an epoch fragmentation index per hour of recording.
#calculate_frequency_metrics
fn calculate_frequency_metrics(intervals : Array[Double], sample_rate_hz : Double) -> FrequencyMetricsCompute conventional VLF, LF, and HF HRV bands.
#calculate_geometric_metrics
Calculate histogram-based triangular index and an approximate TINN width.
#calculate_load_dose
#calculate_load_ratio
fn calculate_load_ratio(days : Array[DailyLoadLedger], acute_window : Int, chronic_window : Int) -> Double#calculate_metrics
fn calculate_metrics(intervals : Array[Double], config : HrvConfig, quality : QualityReport) -> HrvMetricsCalculate all time-domain HRV metrics for cleaned intervals.
#calculate_monotony
Calculate monotony as mean daily load divided by its standard deviation.
#calculate_morning_trends
fn calculate_morning_trends(history : Array[MorningMeasurement], window_size : Int, config : HrvConfig) -> Array[MorningTrend]Calculate morning trends and baseline parameters for a history of measurements.
#calculate_nonlinear_metrics
Calculate all non-linear metrics with robust default parameters.
#calculate_periodogram
Calculate a real-valued DFT periodogram for a sampled sequence.
#calculate_pnn
Calculate the percentage of successive RR intervals differing by more than threshold_ms.
#calculate_pnn_fraction
Calculate a robust pNN metric using an arbitrary threshold.
#calculate_poincare
Calculate SD1 and SD2 from successive RR pairs.
#calculate_readiness
fn calculate_readiness(today_rmssd : Double, baseline : RobustBaseline, trend_slope : Double, quality_ratio : Double) -> ReadinessScoreCalculate readiness from today's RMSSD, a baseline, and signal quality.
#calculate_readiness_series
fn calculate_readiness_series(history : Array[MorningMeasurement], config : HrvConfig) -> Array[ReadinessScore]Turn a morning history into readiness scores with robust baselines.
#calculate_recovery_score
#calculate_rmssd
Calculate the Root Mean Square of Successive Differences (RMSSD).
#calculate_robust_baseline
fn calculate_robust_baseline(values : Array[Double], fence : Double, range_factor : Double) -> RobustBaselineCompute a median/MAD baseline with a configurable outlier fence.
#calculate_sample_entropy
Calculate sample entropy with Chebyshev template distance.
#calculate_sdnn
Calculate the Standard Deviation of NN intervals (SDNN).
#calculate_sdsd
Calculate the standard deviation of successive differences.
#calculate_sleep_efficiency
Calculate sleep efficiency from epoch durations.
#calculate_spectral_profile
fn calculate_spectral_profile(intervals : Array[Double], sample_rate_hz : Double, bands : Array[SpectralBand]) -> SpectralProfileCalculate the spectral profile for a tachogram.
#calculate_strain
Calculate training strain as total load multiplied by monotony.
#calculate_tinn
Approximate the triangular interpolation of the NN interval histogram.
#calculate_triangular_index
Convenience wrapper using a 7.8125 ms histogram bin.
#calibrate_intervals
Calibrate and retain only values in the profile's range.
#calibrate_value
Convert one raw sensor reading into milliseconds.
#cardiac_vagal_index
Calculate a normalized cardiac vagal index from RMSSD and mean RR.
#changed_windows
Return windows whose values changed by at least a threshold.
#check_runtime_budget
#clamp_to_reference_range
Clamp a value into a reference range.
#classify_activity
Classify a synchronized sample.
#classify_interval
Classify a value against the physiological range in a configuration.
#classify_load_risk
#classify_session_history
fn classify_session_history(observations : Array[SessionObservation], window_size : Int, load_threshold : Double) -> Array[SessionStatus]Create statuses for all observations using a trailing baseline.
#classify_session_status
fn classify_session_status(observation : SessionObservation, baseline_rmssd : Double, baseline_scale : Double, load_threshold : Double) -> SessionStatusCalculate a baseline-relative session status.
#classify_sleep_epoch
fn classify_sleep_epoch(mean_rr : Double, rmssd : Double, movement_score : Double, quality_ratio : Double) -> SleepStageInfer a coarse stage from RR-derived recovery markers.
#clean_rr_intervals
fn clean_rr_intervals(intervals : Array[Double], cleaning_method : CleaningMethod, config : HrvConfig) -> (Array[Double], QualityReport)Clean RR intervals and generate a quality report.
#cleaning_feature_vector
Return a compact cleaning feature vector.
#coefficient_of_variation
Return the coefficient of variation as a percentage.
#cohort_compare
fn cohort_compare(observation : CohortObservation, observations : Array[CohortObservation], quality_floor : Double) -> CohortComparison#cohort_comparisons_csv
#cohort_feature_vector
Return a deterministic cohort feature vector for dashboards.
#cohort_metric_range
fn cohort_metric_range(observations : Array[CohortObservation], metric : String) -> CohortMetricRange#cohort_observation_is_eligible
#cohort_percentile_for
fn cohort_percentile_for(summary : CohortComparisonSummary, reference : String, metric : String) -> Double#cohort_quality_adjusted_score
fn cohort_quality_adjusted_score(observation : CohortObservation, summary : CohortComparisonSummary) -> Double#cohort_ranges
fn cohort_ranges(observations : Array[CohortObservation], quality_floor : Double) -> Array[CohortMetricRange]#cohort_rank
fn cohort_rank(observation : CohortObservation, observations : Array[CohortObservation], metric : String, higher_is_better : Bool, quality_floor : Double) -> CohortRank#cohort_recovery_flag
#cohort_similarity_for
#cohort_summary_feature_vector
#cohort_summary_is_usable
#cohort_training_load_flag
fn cohort_training_load_flag(observation : CohortObservation, summary : CohortComparisonSummary) -> Bool#compare_analysis_reports
Compare two reports using normalized feature distance.
#compare_recordings
Calculate a paired comparison and Bland-Altman-style agreement limits.
#compare_subject_to_cohort
fn compare_subject_to_cohort(subject : SubjectSummary, cohort : Array[SubjectSummary]) -> SubjectSummaryCompare one subject's mean RMSSD with a cohort distribution.
#compare_training_scenarios
fn compare_training_scenarios(plan : TrainingLoadPlan, recovery_score : Double, config : ScenarioConfig) -> ScenarioComparison#comparison_feature_vector
Return a compact comparison feature vector.
#concatenate_feature_tables
Concatenate feature vectors and preserve their source names.
#config_analysis_window_is_safe
#config_forecast_policy_line
#config_quality_floor_is_safe
#config_quality_policy_line
#config_validation_error_keys
#config_validation_has_errors
#config_validation_message
#config_validation_warning_count
#configuration_environment_name
#configuration_is_strict
#continuity_quality_score
Score continuity using large successive changes.
#correlation_value
Pearson correlation for paired values.
#count_activity_state
fn count_activity_state(samples : Array[AmbulatorySample], state : ActivityState, thresholds : ActivityThresholds) -> IntCount samples belonging to a state.
#count_gap_candidates
Count gaps between two plausible beats using a configurable multiplier.
#count_in_reference_range
Count observations inside a reference range.
#count_large_successive_changes
Count intervals whose local change exceeds a threshold.
#count_quality_records
Return the number of records that meet a quality threshold.
#count_turning_points
Count direction changes in a residual sequence.
#covariance_matrix
Calculate a column covariance matrix.
#covariance_value
Return covariance using the sample denominator.
#coverage_quality_score
fn coverage_quality_score(sample_count : Int, minimum : Int, target : Int) -> DoubleScore sample coverage relative to a minimum and target length.
#cumulative_power_frequency
Return the frequency at which a cumulative power fraction is reached.
#date_distance
Return the signed day distance from left to right.
#date_to_ordinal
Convert a valid date to a monotonically increasing day number.
#dates_are_ordered
Return whether dates are strictly increasing.
#days_in_month
fn days_in_month(year : Int, month : Int) -> IntReturn the number of days in a month.
#decision_action
fn decision_action(priority : Int, title : String, instruction : String, duration_minutes : Double, intensity_ceiling : Double, requires_recheck : Bool) -> DecisionAction#decision_actions
fn decision_actions(context : DecisionContext, findings : Array[DecisionFinding], score : Double) -> Array[DecisionAction]#decision_collect_findings
fn decision_collect_findings(context : DecisionContext, thresholds : DecisionThresholds) -> Array[DecisionFinding]#decision_domain_counts
#decision_finding
fn decision_finding(code : String, domain : DecisionDomain, severity : DecisionSeverity, title : String, evidence : String, observed : Double, reference : Double, confidence : Double, action : String) -> DecisionFinding#decision_findings_for_severity
fn decision_findings_for_severity(plan : DecisionPlan, severity : DecisionSeverity) -> Array[DecisionFinding]#decision_load_findings
fn decision_load_findings(plan : TrainingLoadPlan, thresholds : DecisionThresholds) -> Array[DecisionFinding]#decision_max_severity
#decision_plan_feature_vector
#decision_plan_has_domain
#decision_plan_intensity_ceiling
#decision_quality_finding
fn decision_quality_finding(report : QualityReport, thresholds : DecisionThresholds) -> DecisionFinding?#decision_recovery_findings
fn decision_recovery_findings(report : LongitudinalRecoveryReport, thresholds : DecisionThresholds) -> Array[DecisionFinding]#decision_score
#decision_sleep_findings
fn decision_sleep_findings(context : DecisionContext, thresholds : DecisionThresholds) -> Array[DecisionFinding]#decision_symptom_finding
fn decision_symptom_finding(context : DecisionContext, thresholds : DecisionThresholds) -> DecisionFinding?#decompose_trend
Decompose a series into robust baseline and residual.
#default_analysis_feature_table
Create a table from the complete default analysis vector.
#detect_artifact_clusters
fn detect_artifact_clusters(intervals : Array[Double], config : HrvConfig, minimum_count : Int) -> Array[ArtifactCluster]Detect clusters of invalid values in an RR stream.
#detect_change_points
fn detect_change_points(values : Array[Double], window_size : Int, minimum_magnitude : Double) -> Array[ChangePoint]Detect local mean shifts using adjacent windows.
#detect_morning_alerts
fn detect_morning_alerts(history : Array[MorningMeasurement], config : HrvConfig) -> Array[MorningAlert]Detect low/high RMSSD and date-quality alerts.
#detect_rate_episodes
fn detect_rate_episodes(intervals : Array[Double], lower_bpm : Double, upper_bpm : Double, minimum_beats : Int) -> Array[RateEpisode]Detect sustained tachycardia or bradycardia episodes.
#detrend_linear
Remove the least-squares linear trend from a sequence.
#diagnose_signal
Build a dashboard diagnostic without running the full spectral pipeline.
#diagnostic_csv
Export a diagnostic as CSV.
#diagnostic_recommendation
Return a one-line recommendation for a signal-quality card.
#dominant_activity_state
Choose the state with the largest duration.
#dominant_autocorrelation_lag
fn dominant_autocorrelation_lag(values : Array[Double], minimum_lag : Int, maximum_lag : Int) -> IntEstimate the dominant period in samples from autocorrelation peaks.
#dominant_band_name
Find the band with the largest absolute power.
#dominant_spectrum_bin
Return the largest non-DC spectrum bin.
#downsample_mean
Downsample a sequence by averaging fixed-size blocks.
#endpoint_change
Return the signed change between the endpoints of a series.
#entropy_tolerance
Estimate sample entropy tolerance from a standard deviation multiplier.
#estimate_offset
Apply an offset correction estimated from a reference sequence.
#estimate_respiration
fn estimate_respiration(intervals : Array[Double], config : RespirationConfig) -> RespirationSummaryEstimate respiration from the dominant respiratory spectral peak.
#estimate_respiratory_cycles
fn estimate_respiratory_cycles(intervals : Array[Double], frequency_hz : Double, sample_rate_hz : Double) -> IntEstimate the number of respiratory cycles in a candidate frequency.
#estimate_scale
Estimate a multiplicative scale from paired reference/observed values.
#estimate_trace_rate
Return a respiratory rate from a direct breathing trace.
#evaluate_protocol_run
fn evaluate_protocol_run(plan : ProtocolPlan, results : Array[ProtocolStepResult], tolerance_seconds : Double) -> ProtocolRunReportValidate step results against a plan.
#evaluate_quality_policy
fn evaluate_quality_policy(intervals : Array[Double], config : HrvConfig, policy : QualityPolicy) -> QualityDecisionEvaluate a signal against a policy and return rejection reasons.
#evaluate_quality_with_runs
fn evaluate_quality_with_runs(intervals : Array[Double], config : HrvConfig, minimum_run : Int) -> SignalQualitySummaryReturn a quality summary with a custom run-coverage reason.
#evaluate_signal_quality
fn evaluate_signal_quality(intervals : Array[Double], config : HrvConfig, weights : SignalQualityWeights, minimum_beats : Int, target_beats : Int) -> SignalQualitySummaryEvaluate an RR stream with explainable components.
#ewma_morning_baseline
Return a seven-day exponentially weighted RMSSD baseline.
#exponential_moving_average
Calculate an exponentially weighted moving average.
#exponential_smooth
Smooth a series while preserving its length.
#exponentially_weighted_deviation
Calculate a rolling exponentially weighted baseline and deviations.
#exponentially_weighted_load
#export_document_csv
Export a document as a CSV table.
#export_escape
fn export_escape(value : String) -> StringEscape a value for a simple key-value export.
#export_log_line
Return a compact one-line summary for logs.
#export_review_count
Return the number of rows marked for review.
#export_row
Create one row.
#export_row_is_numeric
Return whether an export row contains a finite numeric value.
#export_rows_ndjson
Export rows as a compact JSON-like line protocol without external state.
#export_training_load_plan_csv
#export_with_provenance
fn export_with_provenance(content : String, source : String) -> StringAdd a provenance footer to a text export.
#feature_completeness
Return a feature completeness ratio.
#feature_names
Return the feature names in table order.
#feature_schema_matches
Return whether two tables have exactly the same feature schema.
#feature_table_distance
Calculate an L2 distance between aligned feature tables.
#feature_table_row
Return a CSV-compatible row with the table values.
#feature_value
Look up a named feature.
#feature_value_or
Look up a named feature and return a fallback when absent.
#feature_values
Return values in table order, replacing missing values with a default.
#fit_feature_scaler
Learn robust center and scale parameters for a table.
#fit_linear_trend
Fit y = slope * x + intercept to an ordered sequence of y values.
#fit_scaler_from_tables
Learn a scaler from aligned feature tables.
#fit_two_feature_regression
Calculate a two-feature least-squares regression with intercept.
#forecast_adjusted_intensity
#forecast_average_interval
#forecast_backtest
fn forecast_backtest(history : Array[Double], algorithm : ForecastMethod, config : ForecastConfig, holdout : Int) -> ForecastBacktest#forecast_bundle_feature_vector
#forecast_coverage
Return the proportion of points inside a confidence interval.
#forecast_last_point
#forecast_linear
Fit a linear forecast and return approximate 95% prediction bounds.
#forecast_mae
Calculate mean absolute forecast error.
#forecast_method_value
fn forecast_method_value(values : Array[Double], algorithm : ForecastMethod, config : ForecastConfig) -> Double#forecast_morning_rmssd
Forecast future RMSSD from a morning history.
#forecast_moving_average
#forecast_point
fn forecast_point(step : Int, value : Double, scale : Double, confidence : Double, algorithm : ForecastMethod, config : ForecastConfig) -> ForecastPoint#forecast_point_at
#forecast_result_feature_vector
#forecast_result_is_usable
#forecast_values
fn forecast_values(history : Array[Double], algorithm : ForecastMethod, config : ForecastConfig) -> OperationalForecastResult#frame_values
Split a sequence into overlapping frames for streaming or spectral work.
#frequency_feature_vector
Return a concise frequency feature vector for model inputs.
#generate_drift_fixture
fn generate_drift_fixture(length : Int, baseline : Double, drift_per_beat : Double) -> Array[Double]Generate a controlled drift fixture.
#generate_resting_fixture
Generate a deterministic resting RR fixture for tests and benchmarks.
#group_training_load_days
fn group_training_load_days(entries : Array[TrainingLoadEntry], config : LoadModelConfig) -> Array[DailyLoadLedger]#has_band_power
Return whether a spectrum has measurable power in a band.
#heart_rate_in_zone
fn heart_rate_in_zone(rate : Double, lower_bpm : Double, upper_bpm : Double) -> BoolReturn whether a heart rate is within a closed zone.
#heart_rate_recovery_after_activity
fn heart_rate_recovery_after_activity(blocks : Array[ActivityBlock], recovery_minutes : Double) -> DoubleEstimate heart-rate recovery after a vigorous block.
#histogram_entropy
Calculate entropy of an amplitude histogram.
#histogram_mode
Return the most populated histogram bin, preferring the lower bin on ties.
#ingest_sorted_wearable_samples
fn ingest_sorted_wearable_samples(input : Array[WearableSample], config : WearableIngestConfig) -> WearableIngestReportIngest after ordering a device batch by timestamp.
#ingest_wearable_samples
fn ingest_wearable_samples(input : Array[WearableSample], config : WearableIngestConfig) -> WearableIngestReportIngest a batch, reject malformed events, and retain an audit trail.
#inject_artifacts
Add deterministic ectopic and boundary artifacts to a fixture.
#inject_missing_run
Inject a deterministic missing-value run.
#inspect_cleaning
fn inspect_cleaning(intervals : Array[Double], cleaning_method : CleaningMethod, config : HrvConfig) -> CleaningResultDetect artifacts and record the replacement used by a cleaning method.
#integrate_band_power
fn integrate_band_power(spectrum : Array[SpectrumBin], lower_hz : Double, upper_hz : Double) -> DoubleSum periodogram power in a half-open frequency interval.
#interpolate_artifact
Interpolate an artifact from the nearest valid neighbors.
#interpolate_at
Linearly interpolate a value at a timestamp, clamping at the endpoints.
#interpolate_spectrum
fn interpolate_spectrum(spectrum : Array[SpectrumBin], step_hz : Double, maximum_hz : Double) -> Array[SpectrumBin]Interpolate a spectrum onto an evenly-spaced frequency grid.
#intervals_to_heart_rate
Convert RR intervals in milliseconds to instantaneous heart rate.
#is_extreme_anomaly
fn is_extreme_anomaly(score : Double, threshold : Double) -> BoolReturn whether a value is an extreme local anomaly.
#is_leap_year
fn is_leap_year(year : Int) -> BoolReturn whether a Gregorian year is a leap year.
#is_publishable
Return whether a report is safe to publish to a dashboard.
#is_recovery_signal_usable
Return whether a signal is acceptable for recovery scoring.
#is_valid_date
fn is_valid_date(year : Int, month : Int, day : Int) -> BoolValidate a Gregorian date.
#last_finite
Return the latest finite value in a stream, or zero when none exists.
#latest_morning_status
fn latest_morning_status(history : Array[MorningMeasurement], config : HrvConfig) -> MorningBaselineStateProduce a robust status for the most recent measurement.
#load_adjusted_recovery
Calculate a load-adjusted recovery score.
#load_alert_for_profile
#load_days_in_range
fn load_days_in_range(days : Array[DailyLoadLedger], start_date : String, end_date : String) -> Array[DailyLoadLedger]#load_dose_recovery_cost
#load_dose_to_row
#load_entry_from_workout
#load_entry_intensity_score
#load_plan_compare
#load_plan_feature_vector
#load_plan_from_workouts
#load_plan_is_more_stressful
#load_plan_next_day_budget
#load_plan_with_quality_floor
fn load_plan_with_quality_floor(entries : Array[TrainingLoadEntry], minimum_quality : Double) -> TrainingLoadPlan#load_recommended_intensity
#load_recovery_correlation
Calculate a workload-to-recovery correlation.
#load_schedule_is_monotonic
#local_median_smooth
Apply a robust local median smoother without deleting samples.
#long_run_coverage
Return the fraction of clean contiguous runs longer than a threshold.
#longest_clean_run
Return the longest contiguous clean run.
#longest_valid_run
Return the longest consecutive run of valid intervals.
#longest_valid_segment
Return the largest contiguous run after removing invalid intervals.
#mad_filter
Remove values outside a median absolute deviation fence.
#make_audit_event
fn make_audit_event(ordinal : Int, run_id : String, timestamp : String, kind : AuditEventKind, outcome : AuditOutcome, component : String, message : String, input_count : Int, output_count : Int, quality_score : Double, checksum : String) -> AuditEvent#make_cohort_observation
fn make_cohort_observation(reference : String, rmssd_ms : Double, mean_rr_ms : Double, resting_hr_bpm : Double, readiness_score : Double, training_load : Double, signal_quality : Double, age_band : String, activity_band : String) -> CohortObservation#make_decision_context
fn make_decision_context(quality_report : QualityReport?, recovery_report : LongitudinalRecoveryReport?, load_plan : TrainingLoadPlan?, sleep_hours : Double, sleep_efficiency : Double, symptom_score : Double, user_goal : String, requested_intensity : Double) -> DecisionContext#make_frequency_band
fn make_frequency_band(name : String, lower_hz : Double, upper_hz : Double, spectrum : Array[SpectrumBin], total_power : Double) -> FrequencyBandPowerCreate a named frequency band from a spectrum.
#make_named_features
fn make_named_features(names : Array[String], values : Array[Double], source : String) -> Array[NamedFeature]Build named features from a vector and a name list.
#make_quality_gate
#make_recovery_day_record
fn make_recovery_day_record(date : String, mean_rr_ms : Double, rmssd_ms : Double, sdnn_ms : Double, resting_hr_bpm : Double, sleep_hours : Double, sleep_efficiency : Double, respiratory_rate : Double, training_load : Double, signal_quality : Double, source : String) -> RecoveryDayRecord#make_reference_range
Build a robust reference range from observed values.
#make_runtime_sample
fn make_runtime_sample(case_name : String, target : String, repetitions : Int, elapsed_ms : Double, input_size : Int, output_size : Int, accepted : Bool) -> RuntimeSample#make_segment_ranges
Build overlapping segment ranges. The final partial segment is omitted.
#make_telemetry_record
fn make_telemetry_record(record_id : String, subject_id : String, source_id : String, timestamp_seconds : Double, rr_ms : Double, heart_rate_bpm : Double, movement_g : Double, temperature_c : Double, signal_quality : Double, tags : Array[String]) -> TelemetryRecord#make_training_load_entry
fn make_training_load_entry(date : String, session_id : String, duration_minutes : Double, average_hr_bpm : Double, maximum_hr_bpm : Double, resting_hr_bpm : Double, rpe : Double, distance_km : Double, elevation_m : Double, signal_quality : Double) -> TrainingLoadEntry#make_wearable_sample
fn make_wearable_sample(timestamp_seconds : Double, rr_ms : Double, heart_rate_bpm : Double, signal_quality : Double, source_id : String, sequence_number : Int) -> WearableSampleMake a sample without requiring a particular device SDK.
#matrix_add
Add two aligned matrices.
#matrix_center
Center each matrix column.
#matrix_column_means
Calculate column means.
#matrix_column_scales
Calculate sample standard deviations by column.
#matrix_copy
Return a deep copy of a matrix.
#matrix_diagonal
Return a diagonal from a square matrix.
#matrix_flatten
Flatten a rectangular matrix row by row.
#matrix_identity
Make an identity matrix.
#matrix_is_usable
Return whether a matrix is finite and rectangular.
#matrix_multiply
Multiply two rectangular matrices.
#matrix_scale
Multiply a matrix by a scalar.
#matrix_shape
Return the shape of a nested array.
#matrix_standardize
Standardize each matrix column, using one as a zero-variance scale.
#matrix_subtract
Subtract two aligned matrices.
#matrix_transpose
Transpose a rectangular matrix.
#matrix_unflatten
Rebuild a matrix from a row-major vector.
#matrix_vector_multiply
Multiply a matrix by a vector.
#matrix_zeros
Make a zero matrix.
#mean_absolute_deviation
Backward-compatible mean absolute deviation around the arithmetic mean.
#mean_value
Return the arithmetic mean, or zero for an empty sequence.
#median_absolute_deviation
Return the median absolute deviation around the sample median.
#median_successive_difference
Calculate the median absolute successive difference.
#median_value
Return the median using the midpoint of the two central values for even
sized samples.
#merge_feature_tables
Merge two feature tables while preferring values from the right table.
#merge_reference_ranges
Return the widest of several reference ranges.
#metrics_rows
Convert core time-domain metrics into a stable table.
#missing_calendar_days
Count missing calendar days in an ordered date series.
#missing_protocol_results
fn missing_protocol_results(plan : ProtocolPlan, results : Array[ProtocolStepResult]) -> Array[ProtocolStepResult]Generate missing step results with actionable notes.
#morning_protocol_plan
Make a resting morning protocol plan.
#moving_average
Calculate an unweighted or zero-filled moving average.
#moving_standard_deviation
Calculate a moving sample standard deviation.
#nonlinear_feature_vector
Return the main non-linear features in stable column order.
#normalize_spectral_band
Clamp and normalize a user-provided spectral band.
#normalize_unit_interval
Normalize values into [0, 1]. Constant sequences map to 0.5.
#normalize_wearable_sample
fn normalize_wearable_sample(sample : WearableSample, config : WearableIngestConfig) -> NormalizedWearableSampleNormalize one sample and report whether a channel was derived.
#normalized_sequence_distance
Compare two aligned sequences with a symmetric normalized distance.
#operational_report_feature_vector
#operational_report_headline
#operational_report_is_usable
#operational_report_markdown
#operational_report_rows_csv
#operational_report_section
fn operational_report_section(report : OperationalReport, kind : ReportSectionKind) -> OperationalReportSection?#operational_report_warning_count
#overnight_recovery_delta
fn overnight_recovery_delta(overnight_rmssd : Double, baseline_rmssd : Double) -> DoubleCompare overnight RMSSD to a personal baseline.
#paired_effect_size
Calculate a paired effect size using the standard deviation of differences.
#parse_csv
CSV Parser using a state-machine. Handles optional double quotes and escapes.
#parse_morning_csv
Parse a CSV string containing historical morning measurements.
#parse_rr_csv
Parse a CSV string containing RR interval numbers.
#parse_simulation_scenario
Parse a scenario name with stable fallback behavior.
#peak_training_days
Return the dates with the largest training loads.
#percentile_rank
Calculate percentile rank using a cohort of scalar values.
#personal_rmssd_range
Calculate a robust personal reference range from a history.
#pipeline_batch_summary
#pipeline_gate_feature_vector
#pipeline_policy_is_conservative
#pipeline_policy_with_minimum_samples
fn pipeline_policy_with_minimum_samples(policy : QualityGatePolicy, samples : Int) -> QualityGatePolicy#pipeline_run_failure_reasons
#pipeline_run_stage
#plausibility_quality_score
Score plausibility of the median and spread.
#population_variance
Population variance, useful for complete windows rather than samples.
#position_in_reference_range
fn position_in_reference_range(value : Double, range : ReferenceRange, standard_deviation_value : Double, population_values : Array[Double]) -> RangePositionCalculate a range position using a supplied standard deviation.
#post_episode_recovery_slope
fn post_episode_recovery_slope(intervals : Array[Double], episode : RateEpisode, observation_beats : Int) -> DoubleReturn a per-beat recovery slope after a detected episode.
#prepare_spectral_values
fn prepare_spectral_values(values : Array[Double], remove_trend : Bool, function : WindowFunction) -> Array[Double]Center and optionally detrend a tachogram before a periodogram.
#prepare_tachogram
fn prepare_tachogram(intervals : Array[Double], sample_rate_hz : Double, remove_trend : Bool, function : WindowFunction) -> TachogramResample, center, detrend, and window an RR series in one call.
#profile_artifacts
Profile artifacts with robust step-based and physiological checks.
#prolonged_awakenings
fn prolonged_awakenings(epochs : Array[SleepEpoch], threshold_minutes : Double) -> Array[SleepEpoch]Return awake intervals longer than a configurable threshold.
#protocol_config_for_name
#protocol_dialect_from_name
#protocol_duration_error
Return a protocol-specific expected recording duration.
#protocol_mapping_for_headers
fn protocol_mapping_for_headers(dialect : WearableProtocolDialect, headers : Array[String]) -> ProtocolColumnMapping#protocol_mapping_is_usable
#protocol_next_action
Return a human-readable next action.
#protocol_normalize_quality
#protocol_notice_count_for
#protocol_parse_csv
#protocol_plan_duration
Return the total planned duration.
#protocol_plan_is_valid
Return whether a plan is internally consistent.
#protocol_recommendation
Return a useful protocol recommendation.
#protocol_rejection_ratio
#protocol_result_feature_vector
#protocol_result_is_usable
#protocol_roundtrip_quality
#protocol_run_feature_vector
Return a protocol feature vector.
#protocol_step
Find a step by ordinal.
#quality_change_is_material
fn quality_change_is_material(left : SignalQualitySummary, right : SignalQualitySummary, threshold : Double) -> BoolReturn whether quality changes are material.
#quality_from_cleaning
Create a score from a cleaning result.
#quality_grade
Return a quality grade suitable for dashboards.
#quality_score_delta
Compare two quality summaries.
#quality_weight
Convert a policy decision into a multiplicative score weight.
#quantile_value
Compute a linearly interpolated quantile in the closed interval [0, 1].
#quantize_interval
fn quantize_interval(value : Double, resolution_ms : Double) -> DoubleQuantize a value to a device resolution while preserving a stable unit.
#quantize_intervals
Quantize an entire recording.
#quantize_simulation
Apply deterministic quantization noise.
#range_center_distance
Return a normalized distance from the center of a range.
#range_quality_score
Score physiological-range compliance.
#rank_sessions_by_recovery
fn rank_sessions_by_recovery(observations : Array[SessionObservation], window_size : Int, load_threshold : Double) -> Array[SessionStatus]Return a sorted copy from highest recovery score to lowest.
#readiness_level
Convert a score into an ordinal readiness level.
#recommend_cleaning_method
Choose a correction method from the observed artifact ratio.
#recommend_recovery_day
Recommend a recovery day when load and recent recovery cost are high.
#reconcile_cardiac_channels
fn reconcile_cardiac_channels(sample : WearableSample, config : WearableIngestConfig) -> (WearableSample, Bool)Reconcile an RR interval and heart rate without changing source metadata.
#recovery_best_day
#recovery_compare_days
fn recovery_compare_days(current : RecoveryDayRecord, previous : RecoveryDayRecord) -> Array[Double]#recovery_confidence
#recovery_data_completeness
#recovery_day_is_better
fn recovery_day_is_better(current : RecoveryDayAssessment, previous : RecoveryDayAssessment) -> Bool#recovery_heart_rate_z
#recovery_quality_ratio
#recovery_recent_records
fn recovery_recent_records(records : Array[RecoveryDayRecord], count : Int) -> Array[RecoveryDayRecord]#recovery_report_feature_vector
#recovery_report_headline
#recovery_report_is_usable
#recovery_report_load_adjustment
#recovery_report_message
#recovery_report_risk_score
#recovery_rmssd_z
#recovery_rr_z
#recovery_score_average
#recovery_score_quantile
fn recovery_score_quantile(assessments : Array[RecoveryDayAssessment], proportion : Double) -> Double#recovery_sleep_z
#recovery_stable_streak
#recovery_status_from_score
#recovery_status_is_actionable
#recovery_trajectory_from_assessments
fn recovery_trajectory_from_assessments(assessments : Array[RecoveryDayAssessment]) -> RecoveryTrajectory#recovery_trajectory_from_scores
#recovery_trajectory_is_positive
#recovery_trend_points
#recovery_worst_day
#recurrence_rate
Calculate recurrence rate using a fixed radius around the median.
#reference_range_coverage
Calculate the coverage ratio of a range.
#reference_range_feature_vector
Create a range feature vector.
#reference_range_interpretation
Return a plain-language range interpretation.
#repair_invalid_intervals
Replace isolated invalid observations while preserving valid runs.
#repair_profiled_artifacts
Repair only the flagged samples and preserve the original length.
#repeat_fixture
Repeat a fixture without sharing its backing array.
#replacements_are_plausible
Check that all replacements are within the configured physiological range.
#report_action_section
#report_decision_section
#report_forecast_section
#report_headline_csv
Export a full report's headline metrics as CSV.
#report_metric
fn report_metric(key : String, label : String, value : Double, unit : String, status : String, confidence : Double) -> OperationalReportMetric#report_overview_section
fn report_overview_section(report : AnalysisReport, gate : QualityGateResult) -> OperationalReportSection#report_recovery_section
#report_section
fn report_section(kind : ReportSectionKind, title : String, summary : String, metrics : Array[OperationalReportMetric], rows : Array[Array[String]], warnings : Array[String]) -> OperationalReportSection#report_summary
Format the report for a compact terminal summary.
#report_table_append
Add a row while preserving the table schema.
#report_table_filter
Return a table with rows selected by a predicate.
#report_table_find
Return the first matching row by its metric key.
#report_table_grid
Convert a report table to a stable JSON-like key/value grid.
#report_table_size
Return the number of data rows.
#report_table_summary
Return a report table summary line for logs.
#report_table_to_csv
Serialize a table with one header row.
#report_training_section
#resample_rr
Resample the instantaneous RR series onto an evenly spaced time grid.
#residual_anomaly_indices
Detect points that exceed a residual threshold.
#respiration_feature_vector
Return a compact respiration feature vector.
#respiration_is_usable
Return whether respiration can be used as a report annotation.
#respiratory_band_ratio
Calculate a respiration-aware LF/HF modulation ratio.
#respiratory_coherence
fn respiratory_coherence(intervals : Array[Double], frequency_hz : Double, sample_rate_hz : Double) -> DoubleCalculate a normalized correlation between RR modulation and a sinusoid.
#respiratory_modulation
Calculate a smoothed RR modulation signal.
#respiratory_modulation_depth
Estimate the modulation depth using robust quartiles.
#respiratory_peak_frequency
Estimate a respiratory peak from the respiratory band.
#respiratory_phase_consistency
fn respiratory_phase_consistency(intervals : Array[Double], frequency_hz : Double, sample_rate_hz : Double) -> DoubleCalculate phase consistency as the mean absolute sinusoidal alignment.
#respiratory_phase_series
Estimate an RR-respiration phase series from a candidate frequency.
#respiratory_rate_bpm
fn respiratory_rate_bpm(frequency_hz : Double) -> DoubleConvert a respiratory frequency to breaths per minute.
#retained_ratio
Return the proportion of the stream retained after removing flags.
#rmssd_windows
Aggregate RMSSD from complete RR windows.
#rolling_anomaly_scores
Calculate a rolling standardized deviation from a local baseline.
#rolling_load_average
#rolling_median
Calculate a robust moving median for display or denoising.
#rolling_residuals
Return a centered moving baseline and residual series.
#rolling_rmssd
Calculate a causal rolling RMSSD series.
#rolling_rmssd_with_stride
Calculate a short-window RMSSD for every complete window.
#rolling_rr_variability
Calculate a causal rolling coefficient of variation.
#rolling_trend_slopes
Calculate a trailing slope for every complete window.
#rr_histogram
Build an integer histogram of RR intervals.
#rr_timestamps
Convert RR durations into cumulative beat timestamps.
#rr_to_bpm
fn rr_to_bpm(interval_ms : Double) -> DoubleConvert a calibrated value into beats per minute.
#run_benchmark
Run repeated analyses and average stable numeric fields.
#run_benchmark_once
Run the full analysis workload once.
#run_hrv_quality_pipeline
fn run_hrv_quality_pipeline(run_id : String, intervals : Array[Double], config : HrvConfig, options : AnalysisOptions, policy : QualityGatePolicy) -> HrvPipelineRun#runtime_acceptance_ratio
#runtime_aggregate_feature_vector
#runtime_budget
fn runtime_budget(case_name : String, target : String, maximum_mean_ms : Double, maximum_p95_ms : Double, minimum_throughput : Double, minimum_stability : Double) -> RuntimeBudget#runtime_has_regression
fn runtime_has_regression(current : RuntimeAggregate, previous : RuntimeAggregate, threshold : Double) -> Bool#runtime_regression_ratio
#runtime_report_feature_vector
#runtime_samples_for
fn runtime_samples_for(samples : Array[RuntimeSample], case_name : String, target : String) -> Array[RuntimeSample]#runtime_throughput_ratio
#sample_delta_seconds
Return the duration between adjacent samples with a safe fallback.
#scalar_windows
Return valid windows according to a schedule.
#scale_feature_table
Apply a center-scale transform.
#scenario_comparison_feature_vector
#scenario_from_plan
fn scenario_from_plan(plan : TrainingLoadPlan, recovery_score : Double, kind : TrainingScenarioKind) -> ScenarioResult#scenario_is_lower_load
#scenario_recommended
#scenario_session
fn scenario_session(date : String, duration_minutes : Double, intensity : Double, purpose : String) -> ScenarioSession#score_latest_morning
Score the current history using a robust baseline and trend.
#segment_activity
fn segment_activity(samples : Array[AmbulatorySample], thresholds : ActivityThresholds, minimum_block_samples : Int) -> Array[ActivityBlock]Segment samples into activity blocks, merging short runs.
#segment_report_table
Build a table containing one row per segment.
#select_features
Select a named subset while preserving the requested order.
#select_load_peaks
#serialize_metrics_csv
Serialize HrvMetrics to CSV string.
#serialize_trends_csv
Serialize morning baseline trends to CSV string.
#session_analytics_feature_vector
Create a fixed-order longitudinal feature vector.
#session_analytics_is_usable
Return whether longitudinal analytics contain enough signal.
#session_baseline
fn session_baseline(observations : Array[SessionObservation], end_exclusive : Int, window_size : Int) -> (Double, Double)Calculate a robust baseline over the preceding sessions.
#session_is_usable
Return whether an observation is usable for longitudinal scoring.
#session_observations_csv
Export a batch of observations as CSV.
#session_outlier_indices
fn session_outlier_indices(observations : Array[SessionObservation], z_threshold : Double, window_size : Int) -> Array[Int]Return indices of sessions that differ materially from a baseline.
#session_review_ratio
Return the proportion of sessions that need review.
#session_training_load
fn session_training_load(duration_minutes : Double, intensity : Double) -> DoubleCalculate a session load as duration multiplied by normalized intensity.
#signal_quality_explanation
Return a human-readable explanation of a quality summary.
#signal_quality_feature_vector
Return a fixed-order quality feature vector.
#signal_quality_grade
fn signal_quality_grade(score : Double) -> StringConvert a score to a stable quality grade.
#simulate_ambulatory_samples
Generate synchronized ambulatory samples from an RR scenario.
#simulate_respiratory_trace
fn simulate_respiratory_trace(length : Int, sample_rate_hz : Double, rate_bpm : Double) -> Array[Double]Generate a direct sinusoidal respiratory trace.
#simulate_rr
Generate one scenario without random state.
#simulate_scenario_matrix
Run all scenarios with one shared length for smoke tests.
#simulate_training_scenario
fn simulate_training_scenario(sessions : Array[ScenarioSession], kind : TrainingScenarioKind, recovery_score : Double, current_ratio : Double, config : ScenarioConfig) -> ScenarioResult#simulation_scenario_names
Return deterministic scenario names for test discovery.
#simulation_summary
Return a compact set of scenario validation metrics.
#sleep_feature_vector
Create a compact sleep feature vector.
#sleep_offset
Return the last epoch that contributes to sleep duration.
#sleep_onset
Return the first sleep onset epoch, if one exists.
#sleep_quality_ratio
Calculate the proportion of epochs with usable signal quality.
#sleep_regularity
Calculate a sleep regularity score from start-time deltas.
#sleep_stage_code
Return a stable numeric code for a sleep stage.
#sleep_stage_is_asleep
Return whether an epoch contributes to sleep duration.
#sleep_stage_minutes
Calculate total minutes spent in a stage.
#sleep_stage_transitions
Count transitions between consecutive scored epochs.
#sleep_summary_is_usable
Return whether an overnight summary is safe to display.
#slice_segment
Copy one segment from an RR series.
#smooth_spectrum
Smooth spectral power with a moving average.
#solve_two_by_two
Solve a two-variable linear system by Cramer's rule.
#sort_recovery_records
#sort_wearable_samples
Sort a batch by timestamp while preserving deterministic tie order.
#spectral_band_power
Calculate power in a band from an already-computed periodogram.
#spectral_centroid
Calculate the power-weighted average frequency.
#spectral_edge_frequency
Return the first frequency whose cumulative power reaches a proportion.
#spectral_entropy
Calculate normalized spectral entropy from non-negative powers.
#spectral_log_slope
Calculate a simple log-log spectral slope.
#spectral_profile_feature_vector
Return a stable spectral feature vector.
#spectral_profile_is_usable
Return whether the spectral profile contains valid finite values.
#split_at_gaps
Split an RR stream at intervals that exceed a physiological gap.
#split_wearable_gaps
fn split_wearable_gaps(samples : Array[WearableSample], maximum_gap_seconds : Double) -> Array[Array[WearableSample]]Split accepted samples at timestamp gaps.
#standard_deviation
Return the sample standard deviation.
#standard_spectral_bands
Standard frequency bands used by short resting recordings.
#stationarity_quality_score
Score local stationarity by comparing first and second half means.
#successive_change_quality
Return a threshold-based quality score for successive changes.
#successive_differences
Return absolute beat-to-beat changes for a recording.
#sum_values
Sum a sequence without changing its order.
#summarize_ambulatory
fn summarize_ambulatory(samples : Array[AmbulatorySample], thresholds : ActivityThresholds) -> AmbulatorySummaryAggregate a synchronized sample day.
#summarize_cohort
Aggregate all records and attach subject percentile ranks.
#summarize_distribution
Return a full distribution summary for a sequence.
#summarize_heart_rate
Calculate a bounded heart-rate summary and time in five percentage zones.
#summarize_recovery_weeks
fn summarize_recovery_weeks(records : Array[RecoveryDayRecord], baseline_window : Int) -> Array[RecoveryWeekSummary]#summarize_segments
fn summarize_segments(intervals : Array[Double], segment_size : Int, hop_size : Int, config : HrvConfig) -> Array[SegmentSummary]Calculate a summary for every full segment in an RR stream.
#summarize_session_analytics
fn summarize_session_analytics(observations : Array[SessionObservation], minimum_quality : Double) -> SessionAnalyticsSummarize a personal session history.
#summarize_sleep_recovery
fn summarize_sleep_recovery(epochs : Array[SleepEpoch], baseline_rmssd : Double) -> SleepRecoverySummaryBuild a complete overnight recovery summary.
#summarize_subjects
Aggregate records by subject.
#summarize_time_domain_extended
Return an extended summary for a cleaned RR sequence.
#summarize_training_days
Group sessions by their ISO date while preserving input order.
#summarize_training_load
fn summarize_training_load(daily_loads : Array[Double], acute_days : Int, chronic_days : Int) -> TrainingLoadSummaryCalculate acute/chronic load using recent and historical windows.
#summarize_training_plan
Calculate schedule-level load, trend, and recovery cost.
#telemetry_gap_count
#telemetry_latest_by_subject
#telemetry_notices_csv
#telemetry_quality_histogram
#telemetry_query_subject
#telemetry_query_window
fn telemetry_query_window(subject_id : String, start_seconds : Double, end_seconds : Double) -> TelemetryQuery#telemetry_records_for_source
fn telemetry_records_for_source(records : Array[TelemetryRecord], source_id : String) -> Array[TelemetryRecord]#telemetry_records_for_subject
fn telemetry_records_for_subject(records : Array[TelemetryRecord], subject_id : String) -> Array[TelemetryRecord]#telemetry_store_feature_vector
#telemetry_store_summary
#telemetry_window_coverage
Return the fraction of windows that contain a usable RR stream.
#telemetry_window_sample_count
Return the number of usable cardiac samples in a window.
#time_domain_feature_names
Return a stable list of feature names matching time_domain_feature_vector.
#time_domain_feature_vector
Build a compact feature vector for downstream models.
#time_domain_is_usable
Return whether an extended summary is numerically usable.
#time_in_heart_rate_zone
fn time_in_heart_rate_zone(intervals : Array[Double], lower_bpm : Double, upper_bpm : Double) -> DoubleCalculate the amount of time spent in a heart-rate zone.
#to_csv
CSV Serializer. Escapes double quotes, commas, and newlines.
#total_spectral_power
Return the total one-sided power.
#training_load_entry_is_valid
#trend_baseline
Estimate a rolling baseline with a centered median window.
#trend_decomposition_is_usable
Return whether the decomposition has aligned finite arrays.
#trend_explained_variance
Calculate variance explained by a fitted line.
#trend_feature_vector
Return a trend feature vector.
#turning_point_ratio
Calculate the proportion of samples that are local turning points.
#valid_duration_seconds
Return the total duration represented by valid intervals.
#valid_features
Return only valid features.
#valid_intervals
Return only values accepted by the configured physiological range.
#validate_application_config
#validate_intervals
Build a validation report without mutating the input.
#validate_recording_protocol
fn validate_recording_protocol(intervals : Array[Double], config : HrvConfig, protocol : RecordingProtocol, dates : Array[String]) -> ProtocolValidationValidate a recording against a protocol.
#variance_value
Sample variance. A sequence with fewer than two values has zero variance.
#vector_distance
Calculate Euclidean distance between aligned vectors.
#vector_squared_norm
Calculate the squared norm of a vector.
#vector_unit_norm
Normalize a vector to unit norm.
#wearable_finite
fn wearable_finite(value : Double) -> BoolCheck whether a floating-point value is usable in a telemetry record.
#wearable_gap_detected
fn wearable_gap_detected(previous_timestamp : Double, current_timestamp : Double, maximum_gap_seconds : Double) -> BoolDetect whether a gap exceeds the configured transport interval.
#wearable_ingest_csv
Serialize a report suitable for a log line or a metrics endpoint.
#wearable_ingest_feature_vector
Produce a compact quality vector for downstream model tables.
#wearable_ingest_is_usable
Return whether an ingestion report has enough accepted cardiac events.
#wearable_mean_quality
Return the average quality of accepted events.
#wearable_quality_weight
fn wearable_quality_weight(value : Double) -> DoubleClamp quality to a finite unit interval for scoring.
#wearable_rr_intervals
Return the accepted RR stream in milliseconds.
#wearable_sample_has_cardiac_value
Return whether a sample carries at least one usable cardiac channel.
#wearable_sample_is_valid
Validate a sample against broad transport-level constraints.
#wearable_sample_with_context
fn wearable_sample_with_context(sample : WearableSample, movement_g : Double, temperature_c : Double) -> WearableSampleReturn a copy with optional movement and temperature channels attached.
#wearable_samples_are_duplicate
Return whether two samples represent the same transport event.
#wearable_timestamps
Return accepted timestamps in seconds.
#weighted_mean
Calculate a weighted mean for paired values. Extra values are ignored.
#weighted_segment_rmssd
Calculate a quality-weighted mean of segment RMSSD values.
#weighted_signal_quality
fn weighted_signal_quality(components : SignalQualityComponents, weights : SignalQualityWeights) -> DoubleCombine components using explicit weights.
#weighted_sleep_hrv
Aggregate RR and RMSSD across epoch summaries using duration weights.
#welch_periodogram
fn welch_periodogram(values : Array[Double], sample_rate_hz : Double, frame_size : Int, hop_size : Int, function : WindowFunction) -> Array[SpectrumBin]Calculate the average spectrum across overlapping Welch frames.
#window_coefficient
Return the window coefficient for an index.
#window_feature_vector
Convert scalar windows to a compact feature vector.
#window_mean
Return the mean of a window field.
#window_mean_trend
Return the slope of window means.
#window_quality_change
Compare two adjacent windows for a meaningful quality change.
#window_rmssd_summary
Calculate the median and spread of window RMSSD values.
#window_wearable_samples
fn window_wearable_samples(samples : Array[WearableSample], window_seconds : Double, step_seconds : Double, maximum_gap_seconds : Double) -> Array[TelemetryWindow]Window accepted samples by duration and step.
#windows_are_ordered
Return whether windows have monotonic, non-overlapping indices.
#workout_load
Calculate the load of one session.
#worst_quality_window
Return the window with the lowest quality.
#worst_scalar_window
Return the worst window by a scalar field.
Source Files
- advanced_indicators.mbt
- ambulatory.mbt
- application_audit.mbt
- artifact_quality.mbt
- batch.mbt
- benchmarks.mbt
- calendar.mbt
- calibration.mbt
- cleaning.mbt
- cleaning_plus.mbt
- cohort_plus.mbt
- comparison.mbt
- configuration_registry.mbt
- decision_support.mbt
- diagnostics.mbt
- event_detection.mbt
- export_plus.mbt
- forecast.mbt
- forecast_plus.mbt
- formatting.mbt
- frequency.mbt
- hrvkit.mbt
- indicators.mbt
- longitudinal_plus.mbt
- matrix.mbt
- model_features.mbt
- morning.mbt
- morning_plus.mbt
- nonlinear.mbt
- parser.mbt
- pipeline.mbt
- population_ranges.mbt
- protocol_adapters.mbt
- protocol_engine.mbt
- protocols.mbt
- quality_pipeline.mbt
- quality_policy.mbt
- readiness.mbt
- reporting.mbt
- reporting_plus.mbt
- resampling.mbt
- respiration.mbt
- rolling_windows_plus.mbt
- runtime_diagnostics.mbt
- scenario_planner.mbt
- segments.mbt
- session.mbt
- session_analytics.mbt
- signal_quality_plus.mbt
- simulation_plus.mbt
- sleep_recovery.mbt
- spectral_tools.mbt
- statistics.mbt
- streaming.mbt
- synthetic.mbt
- telemetry_store.mbt
- time_domain_plus.mbt
- training_load_plus.mbt
- trend_decomposition.mbt
- validation.mbt
- wearable_pipeline.mbt
- windowed_analysis.mbt
- workout.mbt
Heart Rate Variability (HRV) toolkit in MoonBit for recovery monitoring and training status analysis.
hrvheart-rate-variabilityhealthsports-science
0.3.0
Apache-2.0
Updated 6 hours ago
1 downloads