Kalman Filter Tutorial

[jasonbeach]

I've been trying to wade through the Kalman Filter tutorial. I'm relatively experienced with C++ but not particularly strong with template meta-programming so to be honest, kalman.h is a bit daunting and is why I haven't really started using the library even though I've been aware of it for some time (still trying to figure out how to have a matrix of mixed units.) I really want to though.

Looking at it again yesterday I think a better example would be to allow the user to define the state specific to the use-case as opposed to have a generic state struct that is a giant tuple. So instead of

// state
 template<QuantityOrQuantityPoint... QQPs>
   requires(sizeof...(QQPs) > 0) && (sizeof...(QQPs) <= 3) && are_time_derivatives<QQPs...>
 struct state {
   std::tuple<QQPs...> variables_;
   constexpr state(QQPs... qqps) : variables_(std::move(qqps)...) {}
 };

making it simply something like

struct state{
  fs_vector<si::length<si::metre>, 3> position;
  fs_vector<si::speed<si::metre_per_second>,3> velocity;
  // etc. 
};

This more than likely wouldn't allow the generic state_update, covariance_update and state_extrapolation functions.
I tried to extend example2 (tracking the constant velocity aircraft in one dimension to two dimensions, but the generic definitions in the kalman.h didn't appear to support this and it wasn't obvious what needed to change to support this.

I guess defining state the way it is in the example gives it a vector like feel--a mathematical vector is what you would ideally need to do the linear algebra properly, but I didn't see any obvious examples of using units in a matrix. I believe this was something @chiphogg was working on too).

So I guess I'm curious what other's experiences are in using this library in a linear algebra / more complex filtering contexts are.

[mpusz]

Hi @jasonbeach

Thanks for your interest in the library 😉

I must admit that I do not have much experience in Kalman filters. Also, as you stated, there is no library algebra library on the market that allows different types of matrix rows/columns, at least until we will do it based on https://www.youtube.com/watch?v=4LmMwhM8ODI.

The types in kalman.h are explicitly designed to address the first examples from https://www.kalmanfilter.net and may not be generic enough to address other kalman filter-based problems. If you have any recommendations on how to improve those library usage examples, I would be glad to merge your PR.

Some comments:

as opposed to have a generic state struct that is a giant tuple

state is not giant at all. In all of the examples, it has only one, two, or three members. For example (based on the V2 branch):

kalman_filter-example_1.cpp

using state = kalman::state<quantity<isq::mass[g]>>;
const state initial = {1 * kg};

kalman_filter-example_2.cpp

using state = kalman::state<quantity<isq::position_vector[m]>, quantity<isq::velocity[m / s]>>;
const state initial = {30 * km, 40 * (m / s)};

kalman_filter-example_4.cpp

using state = kalman::state<quantity<isq::position_vector[m]>, quantity<isq::velocity[m / s]>,
                            quantity<isq::acceleration[m / s2]>>;
const state initial = {30 * km, 50 * (m / s), 0 * (m / s2)};

kalman_filter-example_5.cpp

const estimation initial = {state{isq::height(60. * m)}, pow<2>(isq::height(15. * m))};

kalman_filter-example_8.cpp

const estimation initial = {state{quantity_point{10. * deg_C}}, pow<2>(100. * deg_C)};

Please note that in the last example, I used it with temperatures, so your example would not work. Also, I would need at least three such fixed structures for different numbers of quantities and their different types.

[chiphogg]

There are two parts to a good solution for combining linear algebra with units of measure.

1. Handling the units (including possibly heterogeneous units).
2. Tracking reference frames (also mentioned in QuanityKind and Altitudes #457).

In my library, this future work is tracked in aurora-opensource/au#70. Here's the gist of the state of affairs.

• The units part alone is fairly straightforward. I had a working proof of concept in 2021.
• Compared to units, reference frames add much more value, but they also take much more work. That's what's blocking me from trying to tackle this: figuring out good user-friendly APIs I'm happy with.
• Right now, my company (myself very much included) is laser-focused on getting our first product to market, which doesn't leave me the mental bandwidth I'd need to try implementing this.
• @dwith-ts has the only implementation I'm aware of that does both in a units library, but his library isn't publicly available.

There is some chance I'd be able to fix up the proof of concept I did a couple of years ago, and add it under a new au::experimental namespace. It wouldn't be trivial, because it was based on an older version of the library. I have a good idea how I could change Au to accommodate it, but it might introduce compile time regressions for people who don't need the linear algebra part, so I want to be sure that doesn't happen first.

If this does end up happening, it would support mixed-unit vectors and matrices, which I assume would be good enough for the kalman filter example. It would also show people how to implement this kind of matrix wrapper, which could stimulate some to make their own.

It's not especially likely that I'll be able to do this any time soon, but hey, there's a chance!