A lot of progress.

src/fitter/recursive.rs

@@ -1,5 +1,3 @@
-use std::mem;
-
 use ndarray::prelude::*;
 use ndarray::stack;
 
@@ -18,8 +16,8 @@ pub struct RecursiveFitter {
     is_fitted: bool,
     h: Array1<f64>,
     i: ArrayD<f64>,
-    a: ArrayD<f64>,
-    q: ArrayD<f64>,
+    a: Vec<Array2<f64>>,
+    q: Vec<Array2<f64>>,
     m_p: ArrayD<f64>,
     p_p: ArrayD<f64>,
     m_f: ArrayD<f64>,
@@ -44,8 +42,8 @@ impl RecursiveFitter {
             is_fitted: true,
             h,
             i: Array::eye(m).into_dyn(),
-            a: Array::zeros((0, m, m)).into_dyn(),
-            q: Array::zeros((0, m, m)).into_dyn(),
+            a: Vec::new(),
+            q: Vec::new(),
             m_p: Array::zeros((0, m)).into_dyn(),
             p_p: Array::zeros((0, m, m)).into_dyn(),
             m_f: Array::zeros((0, m)).into_dyn(),
@@ -90,7 +88,7 @@ impl Fitter for RecursiveFitter {
             .collect::<Vec<f64>>();
 
         let mean = Array::from_shape_vec((self.ts_new.len(), self.kernel.order()), mean)
-            .unwrap()
+            .expect("failed to create mean matrix")
             .into_dyn();
 
         let cov = self
@@ -109,7 +107,7 @@ impl Fitter for RecursiveFitter {
             (self.ts_new.len(), self.kernel.order(), self.kernel.order()),
             cov,
         )
-        .unwrap()
+        .expect("failed to create cov matrix")
         .into_dyn();
 
         self.m_p = stack![Axis(0), self.m_p, mean];
@@ -122,35 +120,58 @@ impl Fitter for RecursiveFitter {
         self.p_s = stack![Axis(0), self.p_s, cov];
 
         // Compute the new transition and noise covariance matrices.
-        let m = self.kernel.order();
-
-        self.a = stack![Axis(0), self.a, Array::zeros((n_new, m, m)).into_dyn()];
-        self.q = stack![Axis(0), self.q, Array::zeros((n_new, m, m)).into_dyn()];
-
         for i in (self.ts.len() - n_new)..self.ts.len() {
             if i == 0 {
                 continue;
             }
 
-            self.a[i - 1] = self.kernel.transition(self.ts[i - 1], self.ts[1]);
-            // self.q[i - 1] = self.kernel.noise_cov(self.ts[i - 1], self.ts[1]);
+            self.a
+                .push(self.kernel.transition(self.ts[i - 1], self.ts[i]));
+            self.q
+                .push(self.kernel.noise_cov(self.ts[i - 1], self.ts[i]));
         }
 
-        todo!();
+        let m = self.kernel.order();
 
-        /*
-        for i in range(len(self.ts) - n_new, len(self.ts)):
-            if i == 0:
-                # Very first sample, no need to compute anything.
-                continue
-            self._A[i-1] = self.kernel.transition(self.ts[i-1], self.ts[i])
-            self._Q[i-1] = self.kernel.noise_cov(self.ts[i-1], self.ts[i])
-        # Clear the list of pending samples.
-        self.ts_new = list()
-        */
+        self.a.push(Array2::zeros((m, m)));
+        self.q.push(Array2::zeros((m, m)));
+
+        self.ts_new.clear();
     }
 
     fn fit(&mut self) {
         todo!();
     }
+
+    fn vs(&self, idx: usize) -> f64 {
+        *&self.vs[idx]
+    }
+
+    fn vs_mut(&mut self, idx: usize) -> &mut f64 {
+        &mut self.vs[idx]
+    }
+
+    fn ms(&self, idx: usize) -> f64 {
+        *&self.ms[idx]
+    }
+
+    fn ms_mut(&mut self, idx: usize) -> &mut f64 {
+        &mut self.ms[idx]
+    }
+
+    fn xs(&self, idx: usize) -> f64 {
+        *&self.xs[idx]
+    }
+
+    fn xs_mut(&mut self, idx: usize) -> &mut f64 {
+        &mut self.xs[idx]
+    }
+
+    fn ns(&self, idx: usize) -> f64 {
+        *&self.ns[idx]
+    }
+
+    fn ns_mut(&mut self, idx: usize) -> &mut f64 {
+        &mut self.ns[idx]
+    }
 }