Function linear_fill

nodedb/src/engine/timeseries/gap_fill.rs:128–175

Linear interpolation between surrounding real values.

(
    target_ts: i64,
    preceding: &[(i64, AggResult)],
    existing: &std::collections::HashMap<i64, &AggResult>,
    interval_ms: i64,
    end_ms: i64,
)

/// Linear interpolation between surrounding real values.
fn linear_fill(
    target_ts: i64,
    preceding: &[(i64, AggResult)],
    existing: &std::collections::HashMap<i64, &AggResult>,
    interval_ms: i64,
    end_ms: i64,
) -> AggResult {
    // Find last real value before target.
    let prev = preceding.iter().rev().find(|(_, a)| a.count > 0);

    // Find next real value after target.
    let mut next_ts = target_ts + interval_ms;
    let mut next: Option<(i64, &AggResult)> = None;
    while next_ts < end_ms {
        if let Some(agg) = existing.get(&next_ts) {
            next = Some((next_ts, agg));
            break;
        }
        next_ts += interval_ms;
    }

    match (prev, next) {
        (Some((prev_ts, prev_agg)), Some((next_ts, next_agg))) => {
            let t = (target_ts - prev_ts) as f64 / (next_ts - prev_ts) as f64;
            let avg_prev = if prev_agg.count > 0 {
                prev_agg.sum / prev_agg.count as f64
            } else {
                0.0
            };
            let avg_next = if next_agg.count > 0 {
                next_agg.sum / next_agg.count as f64
            } else {
                0.0
            };
            let interpolated = avg_prev + t * (avg_next - avg_prev);
            literal_agg(interpolated)
        }
        (Some((_, prev_agg)), None) => {
            // No next value: flat extrapolation from prev.
            prev_agg.clone()
        }
        (None, Some((_, next_agg))) => {
            // No prev value: flat extrapolation from next.
            (*next_agg).clone()
        }
        (None, None) => null_agg(),
    }
}

#[cfg(test)]
mod tests {