Merge pull request #12 from segeljakt/rust-rfs

Rust implementation of Recalculate-From-Scratch (ReCalc)

Author: scotts

rust/Cargo.toml

@@ -21,6 +21,7 @@ path               = "src/lib.rs"
 num-traits         = "0.2.12"
 arrayvec           = "0.5.1"
 alga               = "0.9.3"
+rand               = "0.7.3"
 
 [dev-dependencies]
 criterion          = "0.3.3"

rust/src/lib.rs

@@ -40,3 +40,6 @@ where
     /// Returns the aggregate of a subwindow.
     fn range_query(&self, range: Range<Time>) -> Value;
 }
+
+/// Recalculate-From-Scratch
+pub mod recalc;

rust/src/recalc/mod.rs

@@ -0,0 +1,39 @@
+use crate::FifoWindow;
+use alga::general::AbstractMonoid;
+use alga::general::Operator;
+use std::marker::PhantomData;
+use std::collections::VecDeque;
+
+#[derive(Debug)]
+pub struct ReCalc<Value, BinOp>
+where
+    Value: AbstractMonoid<BinOp> + Clone,
+    BinOp: Operator,
+{
+    stack: VecDeque<Value>,
+    op: PhantomData<BinOp>,
+}
+
+impl<Value, BinOp> FifoWindow<Value, BinOp> for ReCalc<Value, BinOp>
+where
+    Value: AbstractMonoid<BinOp> + Clone,
+    BinOp: Operator,
+{
+    fn new() -> ReCalc<Value, BinOp> {
+        ReCalc {
+            stack: VecDeque::new(),
+            op: PhantomData,
+        }
+    }
+    fn push(&mut self, v: Value) {
+        self.stack.push_back(v);
+    }
+    fn pop(&mut self) {
+        self.stack.pop_front();
+    }
+    fn query(&self) -> Value {
+        self.stack
+            .iter()
+            .fold(Value::identity(), |acc, elem| acc.operate(&elem))
+    }
+}

rust/tests/fifo-window.rs

@@ -0,0 +1,102 @@
+use alga::general::AbstractGroup;
+use alga::general::AbstractLoop;
+use alga::general::AbstractMagma;
+use alga::general::AbstractMonoid;
+use alga::general::AbstractQuasigroup;
+use alga::general::AbstractSemigroup;
+use alga::general::Identity;
+use alga::general::Operator;
+use alga::general::TwoSidedInverse;
+use rand::Rng;
+use swag::recalc::*;
+use swag::*;
+
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+struct Value(i32);
+
+#[derive(Copy, Clone, Debug)]
+struct Sum;
+
+impl Operator for Sum {
+    fn operator_token() -> Sum {
+        Sum
+    }
+}
+
+impl Identity<Sum> for Value {
+    fn identity() -> Value {
+        Value(0)
+    }
+}
+
+impl AbstractMagma<Sum> for Value {
+    fn operate(&self, other: &Self) -> Self {
+        Value(self.0 + other.0)
+    }
+}
+
+impl TwoSidedInverse<Sum> for Value {
+    fn two_sided_inverse(&self) -> Value {
+        Value(-self.0)
+    }
+}
+
+impl AbstractSemigroup<Sum> for Value {}
+impl AbstractMonoid<Sum> for Value {}
+impl AbstractQuasigroup<Sum> for Value {}
+impl AbstractLoop<Sum> for Value {}
+impl AbstractGroup<Sum> for Value {}
+
+fn test1<Window>()
+where
+    Window: FifoWindow<Value, Sum>,
+{
+    let mut window = Window::new();
+
+    assert_eq!(window.query(), Value(0));
+
+    window.push(Value(1));
+
+    assert_eq!(window.query(), Value(1));
+
+    window.push(Value(2));
+
+    assert_eq!(window.query(), Value(3));
+
+    window.push(Value(3));
+
+    assert_eq!(window.query(), Value(6));
+
+    window.pop();
+
+    assert_eq!(window.query(), Value(5));
+}
+
+fn test2<Window>()
+where
+    Window: FifoWindow<Value, Sum>,
+{
+    let mut window = Window::new();
+    let mut rng = rand::thread_rng();
+    let numbers: Vec<i32> = (0..1000).map(|_| rng.gen_range(1, 5)).collect();
+    let sum: i32 = numbers.iter().sum();
+    let values = numbers.into_iter().map(Value).collect::<Vec<Value>>();
+    for v in values.clone() {
+        window.push(v);
+    }
+    assert_eq!(window.query(), Value(sum));
+    for _ in values {
+        window.pop();
+    }
+    assert_eq!(window.query(), Value(0));
+}
+
+#[test]
+fn test1_recalc() {
+    test1::<ReCalc<Value, Sum>>();
+}
+
+#[test]
+fn test2_recalc() {
+    test2::<ReCalc<Value, Sum>>();
+}