[12, 9, 10, 13, ...]  // 直近60秒分のバケットのイメージ

• value(last): 最後に更新した時点での値
• last: 最後に更新した時刻
• now: 現在時刻
• duration: 減衰の時間スケール（時定数・実効的な窓幅）

• pointer_time が現在時刻より未来にある: 値が大きい
• pointer_time が現在時刻に近い: 値が1に近い
• pointer_time が現在時刻より過去にある: 値が減衰している

1. Decode（復元）: 現在時刻 \(t\) における減衰後の値を計算
2. Increment（加算）: 復元した値に増分 \(x\) を足す
3. Encode（更新）: 新しい値を元に、次回の計算に使う pointer_time を逆算して保存

use std::sync::atomic::{AtomicI64, Ordering};

const SCALE: f64 = 1_000_000.0;

pub struct RateCounter {
    pointer_time: AtomicI64,
    duration_secs: f64,
}

impl RateCounter {
    pub fn new(duration_secs: f64) -> Self {
        assert!(duration_secs.is_finite() && duration_secs > 0.0);

        Self {
            pointer_time: AtomicI64::new(i64::MIN),
            duration_secs,
        }
    }
}

fn decode_value(raw: i64, now_secs: f64, duration_secs: f64) -> f64 {
    let pointer_time = raw as f64 / SCALE;
    ((pointer_time - now_secs) / duration_secs).exp()
}

fn encode_time(pointer_time: f64) -> i64 {
    (pointer_time * SCALE)
        .round()
        .clamp(i64::MIN as f64, i64::MAX as f64) as i64
}

impl RateCounter {
    pub fn value_at(&self, now_secs: f64) -> f64 {
        let raw = self.pointer_time.load(Ordering::Relaxed);
        decode_value(raw, now_secs, self.duration_secs)
    }

    pub fn increment_at(&self, now_secs: f64, x: f64) {
        assert!(now_secs.is_finite());
        assert!(x.is_finite() && x > 0.0);

        let mut raw = self.pointer_time.load(Ordering::Relaxed);
        loop {
            let old_value = decode_value(raw, now_secs, self.duration_secs);
            let new_value = old_value + x;
            let new_pointer_time = now_secs + self.duration_secs * new_value.ln();
            let new_raw = encode_time(new_pointer_time);

            match self.pointer_time.compare_exchange_weak(
                raw,
                new_raw,
                Ordering::Relaxed,
                Ordering::Relaxed,
            ) {
                Ok(_) => return,
                Err(actual) => raw = actual,
            }
        }
    }
}

use std::time::Instant;

let origin = Instant::now();
let now_secs = origin.elapsed().as_secs_f64();

• 現在値は \(\exp((\mathrm{pointer\_time} - \mathrm{now}) / \mathrm{duration})\) で復元可能
• 加算は保存値をデコード、加算、再エンコードの3ステップで完了
• AtomicI64 のようなアトミック変数で管理可能

1. Cohen, E., & Strauss, M. J. (2006). "Maintaining Time-Decaying Stream Aggregates". Journal of Algorithms, 59, 19-36. 時間減衰するストリーム集計を一般的に扱うための基礎文献です。
2. Cormode, G., Korn, F., & Tirthapura, S. (2008). "Exponentially Decayed Aggregates on Data Streams". ICDE 2008. 指数減衰集計をデータストリーム上で扱う手法を整理した文献で、本稿の数理的背景に近い内容です。
3. Cormode, G., Shkapenyuk, V., Srivastava, D., & Xu, B. (2009). "Forward Decay: A Practical Time Decay Model for Streaming Systems". ICDE 2009. 固定された時点から前向きに減衰を表現する考え方を導入しており、実装しやすい時間減衰モデルの背景として参考になります。
4. Datar, M., Gionis, A., Indyk, P., & Motwani, R. (2002). "Maintaining Stream Statistics over Sliding Windows". SIAM Journal on Computing. スライディングウィンドウ型のストリーム統計を扱う古典的な文献で、バケットや窓幅ベースの方法との対比に関係します。
5. NIST/SEMATECH Engineering Statistics Handbook, "EWMA Control Charts". EWMAの基本的な考え方と、過去の観測値に指数的に小さくなる重みを与える監視手法の実務的な背景を説明しています。
6. Dropwizard Metrics documentation, "Meters". 実務的なメトリクスライブラリにおけるレート計測の例で、平均レートに加えて1分、5分、15分の移動平均を扱う設計の参考になります。
7. SciPy documentation, scipy.special.logsumexp. log-sum-exp を数値的に安定して計算するための標準的な関数で、本稿の対数領域での加算の理解に役立ちます。