From e9aabc0bf5a14a28280c2593eebb2e4ca5f87d7b Mon Sep 17 00:00:00 2001
From: FrancoisCarouge <francois.carouge@gmail.com>
Date: Sat, 26 Oct 2024 12:39:10 -0700
Subject: [PATCH] [compatibility] mp-units support test

---
 .github/workflows/cppcheck.yml                |   2 +
 include/fcarouge/internal/utility.hpp         |  26 +-
 include/fcarouge/internal/x_z_p_r_f.hpp       |   7 +-
 sample/CMakeLists.txt                         |   2 +-
 support/CMakeLists.txt                        |   2 +
 support/eigen/fcarouge/linalg.hpp             |  16 +-
 support/mp_units/CMakeLists.txt               |  71 +++
 support/mp_units/fcarouge/unit.hpp            |  77 +++
 support/physical/CMakeLists.txt               |  45 ++
 support/physical/fcarouge/physical_linalg.hpp | 439 ++++++++++++++++++
 test/CMakeLists.txt                           |  26 ++
 test/units_kf_1x1x0_building_height.cpp       |  85 ++++
 test/units_kf_6x2x0_vehicle_location.cpp      | 170 +++++++
 13 files changed, 950 insertions(+), 18 deletions(-)
 create mode 100644 support/mp_units/CMakeLists.txt
 create mode 100644 support/mp_units/fcarouge/unit.hpp
 create mode 100644 support/physical/CMakeLists.txt
 create mode 100644 support/physical/fcarouge/physical_linalg.hpp
 create mode 100644 test/units_kf_1x1x0_building_height.cpp
 create mode 100644 test/units_kf_6x2x0_vehicle_location.cpp

diff --git a/.github/workflows/cppcheck.yml b/.github/workflows/cppcheck.yml
index 4988ed3ae..14511a442 100644
--- a/.github/workflows/cppcheck.yml
+++ b/.github/workflows/cppcheck.yml
@@ -46,5 +46,7 @@ jobs:
           -I support/eigen \
           -I support/generator \
           -I support/lazy \
+          -I support/mp_units \
           -I support/naive \
+          -I support/physical \
           .
diff --git a/include/fcarouge/internal/utility.hpp b/include/fcarouge/internal/utility.hpp
index 191e95992..c12e3bcc5 100644
--- a/include/fcarouge/internal/utility.hpp
+++ b/include/fcarouge/internal/utility.hpp
@@ -259,17 +259,24 @@ struct transposer final {
     return value;
   }
 
-  template <typename Matrix>
-    requires requires(Matrix value) { value.transpose(); }
-  [[nodiscard]] inline constexpr auto operator()(const Matrix &value) const {
+  template <typename Type>
+    requires requires(Type value) { value.transpose(); }
+  [[nodiscard]] inline constexpr auto operator()(const Type &value) const {
     return value.transpose();
   }
 
-  template <typename Matrix>
-    requires requires(Matrix value) { transpose(value); }
-  [[nodiscard]] inline constexpr auto operator()(const Matrix &value) const {
+  template <typename Type>
+    requires requires(Type value) { transpose(value); }
+  [[nodiscard]] inline constexpr auto operator()(const Type &value) const {
     return transpose(value);
   }
+
+  // How to, should we force external type to provide a transposition
+  // implementation if the type needs to, should be transposed?
+  template <typename Type>
+  [[nodiscard]] inline constexpr auto operator()(const Type &value) const {
+    return value;
+  }
 };
 
 struct matrix_deducer;
@@ -287,6 +294,13 @@ struct matrix_deducer final {
     requires(eigen<Lhs> or eigen<Rhs>)
   [[nodiscard]] inline constexpr auto operator()(Lhs lhs, Rhs rhs) const ->
       typename decltype(lhs * transposer{}(rhs))::PlainMatrix;
+
+  template <template <typename, typename, typename> typename T, typename M1,
+            typename R1, typename M2, typename R2, typename C>
+    requires(eigen<M1> or eigen<M2>)
+  [[nodiscard]] inline constexpr auto
+  operator()(T<M1, R1, C> lhs,
+             T<M2, R2, C> rhs) const -> T<deduce_matrix<M1, M2>, R1, R2>;
 };
 
 using empty_tuple = std::tuple<>;
diff --git a/include/fcarouge/internal/x_z_p_r_f.hpp b/include/fcarouge/internal/x_z_p_r_f.hpp
index 271a7a0d6..5c9e1cdb3 100644
--- a/include/fcarouge/internal/x_z_p_r_f.hpp
+++ b/include/fcarouge/internal/x_z_p_r_f.hpp
@@ -48,11 +48,14 @@ template <typename State, typename Output> struct x_z_p_r_f {
   using estimate_uncertainty = deduce_matrix<state, state>;
   using output_uncertainty = deduce_matrix<output, output>;
   using state_transition = deduce_matrix<state, state>;
-  using gain = deduce_matrix<state, output>;
   using innovation = output;
   using innovation_uncertainty = output_uncertainty;
+  // Refactor deduce into a deduce_product and deduce_quotient.
+  using gain =
+      std::remove_cvref_t<decltype(std::declval<estimate_uncertainty>() /
+                                   std::declval<innovation_uncertainty>())>;
 
-  static inline const auto i{identity_v<deduce_matrix<state, state>>};
+  static inline const auto i{identity_v<gain>};
 
   state x{zero_v<state>};
   estimate_uncertainty p{identity_v<estimate_uncertainty>};
diff --git a/sample/CMakeLists.txt b/sample/CMakeLists.txt
index e3168a41f..c21dcac69 100644
--- a/sample/CMakeLists.txt
+++ b/sample/CMakeLists.txt
@@ -35,7 +35,7 @@ ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 OTHER DEALINGS IN THE SOFTWARE.
 
 For more information, please refer to <https://unlicense.org> ]]
-
+return() # REMOVE ME
 foreach(SAMPLE "kf_1x1x0_building_height.cpp" "kf_1x1x0_liquid_temperature.cpp"
                "kf_1x1x1_dog_position.cpp")
   get_filename_component(NAME ${SAMPLE} NAME_WE)
diff --git a/support/CMakeLists.txt b/support/CMakeLists.txt
index e89bce2e1..f5934c5ba 100644
--- a/support/CMakeLists.txt
+++ b/support/CMakeLists.txt
@@ -38,7 +38,9 @@ For more information, please refer to <https://unlicense.org> ]]
 
 add_subdirectory("eigen")
 add_subdirectory("main")
+add_subdirectory("mp_units")
 add_subdirectory("naive")
+add_subdirectory("physical")
 
 add_library(kalman_options INTERFACE)
 
diff --git a/support/eigen/fcarouge/linalg.hpp b/support/eigen/fcarouge/linalg.hpp
index fbf4bfe5b..e9d766841 100644
--- a/support/eigen/fcarouge/linalg.hpp
+++ b/support/eigen/fcarouge/linalg.hpp
@@ -95,15 +95,15 @@ constexpr auto operator/(const Numerator &lhs, const Denominator &rhs)
 } // namespace fcarouge
 
 //! @brief Specialization of the standard formatter for the Eigen matrix.
-template <typename Type, auto Row, auto Column, typename Char>
-struct std::formatter<fcarouge::matrix<Type, Row, Column>, Char> {
+template <fcarouge::eigen Matrix, typename Char>
+struct std::formatter<Matrix, Char> {
   constexpr auto parse(std::basic_format_parse_context<Char> &parse_context) {
     return parse_context.begin();
   }
 
   template <typename OutputIterator>
   constexpr auto
-  format(const fcarouge::matrix<Type, Row, Column> &value,
+  format(const Matrix &value,
          std::basic_format_context<OutputIterator, Char> &format_context) const
       -> OutputIterator {
     const Eigen::IOFormat output_format{Eigen::StreamPrecision,
@@ -123,11 +123,10 @@ struct std::formatter<fcarouge::matrix<Type, Row, Column>, Char> {
 
   template <typename OutputIterator>
   constexpr auto
-  format(const fcarouge::matrix<Type, Row, Column> &value,
+  format(const Matrix &value,
          std::basic_format_context<OutputIterator, Char> &format_context) const
       -> OutputIterator
-    requires(fcarouge::matrix<Type, Row, Column>::RowsAtCompileTime == 1 &&
-             fcarouge::matrix<Type, Row, Column>::ColsAtCompileTime != 1)
+    requires(Matrix::RowsAtCompileTime == 1 && Matrix::ColsAtCompileTime != 1)
   {
     const Eigen::IOFormat output_format{Eigen::StreamPrecision,
                                         Eigen::DontAlignCols,
@@ -146,11 +145,10 @@ struct std::formatter<fcarouge::matrix<Type, Row, Column>, Char> {
 
   template <typename OutputIterator>
   constexpr auto
-  format(const fcarouge::matrix<Type, Row, Column> &value,
+  format(const Matrix &value,
          std::basic_format_context<OutputIterator, Char> &format_context) const
       -> OutputIterator
-    requires(fcarouge::matrix<Type, Row, Column>::RowsAtCompileTime == 1 &&
-             fcarouge::matrix<Type, Row, Column>::ColsAtCompileTime == 1)
+    requires(Matrix::RowsAtCompileTime == 1 && Matrix::ColsAtCompileTime == 1)
   {
     return std::format_to(format_context.out(), "{}", value.value());
   }
diff --git a/support/mp_units/CMakeLists.txt b/support/mp_units/CMakeLists.txt
new file mode 100644
index 000000000..6ea86cbda
--- /dev/null
+++ b/support/mp_units/CMakeLists.txt
@@ -0,0 +1,71 @@
+#[[ __          _      __  __          _   _
+| |/ /    /\   | |    |  \/  |   /\   | \ | |
+| ' /    /  \  | |    | \  / |  /  \  |  \| |
+|  <    / /\ \ | |    | |\/| | / /\ \ | . ` |
+| . \  / ____ \| |____| |  | |/ ____ \| |\  |
+|_|\_\/_/    \_\______|_|  |_/_/    \_\_| \_|
+
+Kalman Filter
+Version 0.4.0
+https://github.com/FrancoisCarouge/Kalman
+
+SPDX-License-Identifier: Unlicense
+
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <https://unlicense.org> ]]
+
+include(FetchContent)
+
+FetchContent_Declare(
+  fmt
+  GIT_REPOSITORY "https://github.com/fmtlib/fmt"
+  GIT_SHALLOW TRUE
+  FIND_PACKAGE_ARGS NAMES fmt)
+FetchContent_MakeAvailable(fmt)
+
+FetchContent_Declare(
+  gsl-lite
+  GIT_REPOSITORY "https://github.com/gsl-lite/gsl-lite"
+  GIT_SHALLOW TRUE
+  FIND_PACKAGE_ARGS NAMES gsl-lite)
+FetchContent_MakeAvailable(gsl-lite)
+
+FetchContent_Declare(
+  mp-units
+  GIT_REPOSITORY "https://github.com/mpusz/mp-units"
+  GIT_SHALLOW TRUE
+  SOURCE_SUBDIR "src" FIND_PACKAGE_ARGS NAMES mp-units)
+FetchContent_MakeAvailable(mp-units)
+
+target_compile_options(mp-units INTERFACE $<IF:$<CXX_COMPILER_ID:MSVC>, ,
+                                          -Wno-double-promotion>)
+target_compile_options(mp-units INTERFACE $<IF:$<CXX_COMPILER_ID:MSVC>, ,
+                                          -Wno-undef>)
+
+add_library(kalman_unit_mp_units INTERFACE)
+target_sources(
+  kalman_unit_mp_units INTERFACE FILE_SET "unit_headers" TYPE "HEADERS" FILES
+                                 "fcarouge/unit.hpp")
+target_link_libraries(kalman_unit_mp_units INTERFACE mp-units::mp-units)
diff --git a/support/mp_units/fcarouge/unit.hpp b/support/mp_units/fcarouge/unit.hpp
new file mode 100644
index 000000000..f7d188898
--- /dev/null
+++ b/support/mp_units/fcarouge/unit.hpp
@@ -0,0 +1,77 @@
+/*  __          _      __  __          _   _
+| |/ /    /\   | |    |  \/  |   /\   | \ | |
+| ' /    /  \  | |    | \  / |  /  \  |  \| |
+|  <    / /\ \ | |    | |\/| | / /\ \ | . ` |
+| . \  / ____ \| |____| |  | |/ ____ \| |\  |
+|_|\_\/_/    \_\______|_|  |_/_/    \_\_| \_|
+
+Kalman Filter
+Version 0.4.0
+https://github.com/FrancoisCarouge/Kalman
+
+SPDX-License-Identifier: Unlicense
+
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <https://unlicense.org> */
+
+#ifndef FCAROUGE_UNIT_HPP
+#define FCAROUGE_UNIT_HPP
+
+#include <mp-units/format.h>
+#include <mp-units/framework/quantity.h>
+#include <mp-units/math.h>
+#include <mp-units/systems/si.h>
+
+namespace fcarouge {
+//! @brief The physical unit quantity.
+template <auto Reference, typename Representation>
+using quantity = mp_units::quantity<Reference, Representation>;
+
+template <mp_units::Quantity Type>
+inline constexpr auto identity_v<Type>{Type::one()};
+
+template <mp_units::Quantity Type>
+[[nodiscard]] inline constexpr auto transpose(const Type &value) {
+  return value;
+}
+} // namespace fcarouge
+
+using mp_units::si::metre;
+using mp_units::si::second;
+using mp_units::si::unit_symbols::m;
+using mp_units::si::unit_symbols::m2;
+using mp_units::si::unit_symbols::s;
+using mp_units::si::unit_symbols::s2;
+using mp_units::si::unit_symbols::s3;
+inline constexpr auto s4 = pow<4>(second);
+
+template <typename Scalar> using distance_t = mp_units::quantity<m, Scalar>;
+
+template <typename Scalar> using velocity_t = mp_units::quantity<m / s, Scalar>;
+
+template <typename Scalar>
+using acceleration_t = mp_units::quantity<m / s2, Scalar>;
+
+#endif // FCAROUGE_UNIT_HPP
diff --git a/support/physical/CMakeLists.txt b/support/physical/CMakeLists.txt
new file mode 100644
index 000000000..dbdca3903
--- /dev/null
+++ b/support/physical/CMakeLists.txt
@@ -0,0 +1,45 @@
+#[[ __          _      __  __          _   _
+| |/ /    /\   | |    |  \/  |   /\   | \ | |
+| ' /    /  \  | |    | \  / |  /  \  |  \| |
+|  <    / /\ \ | |    | |\/| | / /\ \ | . ` |
+| . \  / ____ \| |____| |  | |/ ____ \| |\  |
+|_|\_\/_/    \_\______|_|  |_/_/    \_\_| \_|
+
+Kalman Filter
+Version 0.4.0
+https://github.com/FrancoisCarouge/Kalman
+
+SPDX-License-Identifier: Unlicense
+
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <https://unlicense.org> ]]
+
+add_library(kalman_physical_linalg_mp_units_eigen INTERFACE)
+target_sources(
+  kalman_physical_linalg_mp_units_eigen
+  INTERFACE FILE_SET "unit_headers" TYPE "HEADERS" FILES
+            "fcarouge/physical_linalg.hpp")
+target_link_libraries(kalman_physical_linalg_mp_units_eigen
+                      INTERFACE kalman kalman_unit_mp_units kalman_linalg_eigen)
diff --git a/support/physical/fcarouge/physical_linalg.hpp b/support/physical/fcarouge/physical_linalg.hpp
new file mode 100644
index 000000000..56f4c95cb
--- /dev/null
+++ b/support/physical/fcarouge/physical_linalg.hpp
@@ -0,0 +1,439 @@
+/*  __          _      __  __          _   _
+| |/ /    /\   | |    |  \/  |   /\   | \ | |
+| ' /    /  \  | |    | \  / |  /  \  |  \| |
+|  <    / /\ \ | |    | |\/| | / /\ \ | . ` |
+| . \  / ____ \| |____| |  | |/ ____ \| |\  |
+|_|\_\/_/    \_\______|_|  |_/_/    \_\_| \_|
+
+Kalman Filter
+Version 0.4.0
+https://github.com/FrancoisCarouge/Kalman
+
+SPDX-License-Identifier: Unlicense
+
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <https://unlicense.org> */
+
+#ifndef FCAROUGE_PHYSICAL_LINALG_HPP
+#define FCAROUGE_PHYSICAL_LINALG_HPP
+
+//! @file
+//! @brief Physically typed linear algebra implementation.
+//!
+//! @details Matrix, vectors, and named algebraic values.
+//!
+//! @note Idea from:
+//! https://meetingcpp.com/mcpp/slides/2021/Physical-units-for-matrices6397.pdf
+
+#include "fcarouge/linalg.hpp"
+#include "fcarouge/utility.hpp"
+
+#include <concepts>
+#include <cstddef>
+#include <format>
+#include <initializer_list>
+#include <tuple>
+
+namespace fcarouge {
+
+//! @name Algebraic Types
+//! @{
+
+//! @brief Physical matrix.
+//!
+//! @details Compose a matrix into a physical matrix. Supports type safety. Unit
+//! safety. Row and column indexes provide each index type.
+//!
+//! @tparam Matrix The underlying linear algebra matrix.
+//! @tparam RowIndexes The packed types of the row indexes.
+//! @tparam ColumnIndexes The packed types of the column indexes.
+//!
+//! @todo Explore various types of indexes: arithmetic, units, frames, etc...
+template <typename Matrix, typename RowIndexes, typename ColumnIndexes>
+class physical_matrix {
+public:
+  inline constexpr physical_matrix() = default;
+
+  inline constexpr physical_matrix(const physical_matrix &other) = default;
+
+  inline constexpr physical_matrix &
+  operator=(const physical_matrix &other) = default;
+
+  inline constexpr physical_matrix(physical_matrix &&other) = default;
+
+  inline constexpr physical_matrix &
+  operator=(physical_matrix &&other) = default;
+
+  template <typename M, typename R, typename C>
+  inline constexpr physical_matrix &
+  // Unsafe?
+  operator=(const physical_matrix<M, R, C> &other) {
+    data = other.data;
+    return *this;
+  }
+
+  // Add move assignement?
+
+  // Unsafe?
+  template <eigen Type>
+  explicit inline constexpr physical_matrix(const Type &other) : data{other} {}
+
+  // Column Vector
+  // How to use RowIndexes as elements' types in declaration?
+  explicit inline constexpr physical_matrix(const auto &...elements)
+    requires(std::tuple_size_v<RowIndexes> != 1 &&
+             std::tuple_size_v<ColumnIndexes> == 1 &&
+             sizeof...(elements) == std::tuple_size_v<RowIndexes>)
+  {
+    std::tuple element_pack{elements...};
+    for_constexpr<0, std::tuple_size_v<RowIndexes>, 1>(
+        [this, &element_pack](auto position) {
+          data[position] = std::tuple_element_t<position, RowIndexes>::convert(
+              std::get<position>(element_pack));
+        });
+  }
+
+  // Row Vector
+  explicit inline constexpr physical_matrix(const auto &...elements)
+    requires(std::tuple_size_v<RowIndexes> == 1 &&
+             std::tuple_size_v<ColumnIndexes> != 1 &&
+             sizeof...(elements) == std::tuple_size_v<ColumnIndexes>)
+  {
+    std::tuple element_pack{elements...};
+    for_constexpr<0, std::tuple_size_v<ColumnIndexes>, 1>([this, &element_pack](
+                                                              auto position) {
+      data[position] = std::tuple_element_t<position, ColumnIndexes>::convert(
+          std::get<position>(element_pack));
+    });
+  }
+
+  // 1x1 Fuse me in one of the column?
+  explicit inline constexpr physical_matrix(const auto &element)
+    requires(std::tuple_size_v<RowIndexes> == 1 &&
+             std::tuple_size_v<ColumnIndexes> == 1)
+  {
+    // get proper index type from both indexes?
+    data[0] = std::tuple_element_t<0, ColumnIndexes>::convert(element);
+  }
+
+  template <typename Type>
+  inline constexpr explicit physical_matrix(
+      std::initializer_list<std::initializer_list<Type>> rows) {
+    // static_cast<void>(rows);
+    // for (decltype(Row) i{0}; const auto &row : rows) {
+    //   for (decltype(Column) j{0}; const auto &element : row) {
+    //     data[i][j] = element;
+    //     ++j;
+    //   }
+    //   ++i;
+    // }
+
+    for (std::size_t i{0}; const auto &row : rows) {
+      for (std::size_t j{0}; const auto &element : row) {
+        // Converison works because all types must be the same.
+        data(i, j) = std::tuple_element_t<0, ColumnIndexes>::convert(element);
+        ++j;
+      }
+      ++i;
+    }
+  }
+
+  template <typename Type>
+  explicit inline constexpr physical_matrix([[maybe_unused]] const Type &other)
+      : data{other.data} {}
+
+  // inline constexpr explicit physical_matrix(
+  //     [[maybe_unused]] const auto& v) {
+  //       static_assert(std::is_same_v<void, decltype(v)>);
+  //     }
+
+  // conversion...
+  // [[nodiscard]] inline constexpr explicit(false) operator Type() const
+  //   requires(std::tuple_size_v<RowIndexes> == 1 &&
+  //            std::tuple_size_v<ColumnIndexes> == 1)
+  // {
+  //   using type =
+  //       decltype(typename std::tuple_element_t<0, RowIndexes>::type{} *
+  //                typename std::tuple_element_t<0, ColumnIndexes>::type{});
+
+  //   return data[0][0] * fcarouge::identity_v<type>;
+  // }
+
+  // Implement tuple runtime index....
+  // [[nodiscard]] inline constexpr const auto &operator[](auto index) const
+  //   requires(std::tuple_size_v<RowIndexes> != 1 &&
+  //            std::tuple_size_v<ColumnIndexes> == 1)
+  // {
+  //   using type =
+  //       decltype(typename std::tuple_element_t<index, RowIndexes>::type{} *
+  //                typename std::tuple_element_t<0, ColumnIndexes>::type{});
+
+  //   return data[index][0] * fcarouge::identity_v<type>;
+  // }
+
+  // [[nodiscard]] inline constexpr const auto &operator[](auto index) const
+  //   requires(std::tuple_size_v<RowIndexes> == 1)
+  // {
+  //   using type =
+  //       decltype(typename std::tuple_element_t<0, RowIndexes>::type{} *
+  //                typename std::tuple_element_t<index,
+  //                ColumnIndexes>::type{});
+
+  //   return data[0][index] * fcarouge::identity_v<type>;
+  // }
+
+  // [[nodiscard]] inline constexpr const auto &operator()(auto index) const
+  //   requires(std::tuple_size_v<RowIndexes> != 1 &&
+  //            std::tuple_size_v<ColumnIndexes> == 1)
+  // {
+  //   using type =
+  //       decltype(typename std::tuple_element_t<index, RowIndexes>::type{} *
+  //                typename std::tuple_element_t<0, ColumnIndexes>::type{});
+
+  //   return data[index][0] * fcarouge::identity_v<type>;
+  // }
+
+  // [[nodiscard]] inline constexpr const auto &operator()(auto index) const
+  //   requires(std::tuple_size_v<RowIndexes> == 1)
+  // {
+  //   using type =
+  //       decltype(typename std::tuple_element_t<0, RowIndexes>::type{} *
+  //                typename std::tuple_element_t<index,
+  //                ColumnIndexes>::type{});
+
+  //   return data[0][index] * fcarouge::identity_v<type>;
+  // }
+
+  // [[nodiscard]] inline constexpr const auto &operator()(auto row,
+  //                                                       auto column) const {
+  //   using type =
+  //       decltype(typename std::tuple_element_t<row, RowIndexes>::type{} *
+  //                typename std::tuple_element_t<column,
+  //                ColumnIndexes>::type{});
+
+  //   return data[row][column] * fcarouge::identity_v<type>;
+  // }
+
+  Matrix data;
+};
+
+// Is int the right type for promotion rules in all cases? Move to utility?
+struct placeholder_index {
+  using type = int;
+};
+using one_row = std::tuple<placeholder_index>;
+using one_column = std::tuple<placeholder_index>;
+
+//! @brief Column vector.
+template <typename Matrix, typename... RowIndexes>
+using physical_column_vector =
+    physical_matrix<Matrix, std::tuple<RowIndexes...>, one_column>;
+
+//! @brief Row vector.
+template <typename Matrix, typename... ColumnIndexes>
+using physical_row_vector =
+    physical_matrix<Matrix, one_row, std::tuple<ColumnIndexes...>>;
+
+//! @}
+
+//! @name Deduction Guides
+//! @{
+
+//! @}
+
+//! @name Algebraic Named Values
+//! @{
+
+//! @brief The identity matrix physical specialization.
+template <typename Matrix, typename RowIndexes, typename ColumnIndexes>
+inline physical_matrix<Matrix, RowIndexes, ColumnIndexes>
+    identity_v<physical_matrix<Matrix, RowIndexes, ColumnIndexes>>{
+        identity_v<Matrix>};
+
+//! @brief The zero matrix physical specialization.
+template <typename Matrix, typename RowIndexes, typename ColumnIndexes>
+inline physical_matrix<Matrix, RowIndexes, ColumnIndexes>
+    zero_v<physical_matrix<Matrix, RowIndexes, ColumnIndexes>>{zero_v<Matrix>};
+
+//! @}
+
+template <typename Matrix1, typename Matrix2, typename Row, typename Column>
+[[nodiscard]] inline constexpr auto
+operator+(const physical_matrix<Matrix1, Row, Column> &lhs,
+          const physical_matrix<Matrix2, Row, Column> &rhs) {
+  auto result{lhs.data + rhs.data};
+
+  return physical_matrix<decltype(result), Row, Column>{result};
+}
+
+template <typename Matrix1, typename Matrix2, typename Row, typename Column>
+[[nodiscard]] inline constexpr auto
+operator-(const physical_matrix<Matrix1, Row, Column> &lhs,
+          const physical_matrix<Matrix2, Row, Column> &rhs) {
+  auto result{lhs.data - rhs.data};
+
+  return physical_matrix<decltype(result), Row, Column>{result};
+}
+
+template <typename Matrix1, typename Matrix2, typename Row, typename Size,
+          typename Column>
+[[nodiscard]] inline constexpr auto
+operator*(const physical_matrix<Matrix1, Row, Size> &lhs,
+          const physical_matrix<Matrix2, Size, Column> &rhs) {
+  auto result{lhs.data * rhs.data};
+
+  return physical_matrix<decltype(result), Row, Column>{result};
+}
+
+template <typename Scalar, typename Matrix2, typename Row, typename Column>
+[[nodiscard]] inline constexpr auto
+operator*(Scalar lhs, const physical_matrix<Matrix2, Row, Column> &rhs) {
+  auto result{lhs * rhs.data};
+
+  return physical_matrix<decltype(result), Row, Column>{result};
+}
+
+template <typename Matrix1, typename Matrix2, typename Row1, typename Row2,
+          typename Size>
+[[nodiscard]] inline constexpr auto
+operator/(const physical_matrix<Matrix1, Row1, Size> &lhs,
+          const physical_matrix<Matrix2, Row2, Size> &rhs) {
+  auto result{lhs.data / rhs.data};
+
+  return physical_matrix<decltype(result), Row1, Row2>{result};
+}
+
+template <typename Matrix, typename Row, typename Column>
+[[nodiscard]] inline constexpr auto
+transpose([[maybe_unused]] const physical_matrix<Matrix, Row, Column> &lhs) {
+  internal::transposer t;
+  auto result{t(lhs.data)};
+
+  return physical_matrix<decltype(result), Column, Row>{result};
+}
+} // namespace fcarouge
+
+//! @brief Specialization of the standard formatter for the physical linear
+//! algebra matrix.
+template <typename Matrix, typename RowIndexes, typename ColumnIndexes,
+          typename Char>
+struct std::formatter<
+    fcarouge::physical_matrix<Matrix, RowIndexes, ColumnIndexes>, Char> {
+  constexpr auto parse(std::basic_format_parse_context<Char> &parse_context) {
+    return parse_context.begin();
+  }
+
+  template <typename OutputIterator>
+  constexpr auto format(
+      const fcarouge::physical_matrix<Matrix, RowIndexes, ColumnIndexes> &value,
+      std::basic_format_context<OutputIterator, Char> &format_context) const
+      -> OutputIterator {
+    format_context.advance_to(std::format_to(format_context.out(), "["));
+
+    fcarouge::for_constexpr<0, std::tuple_size_v<RowIndexes>,
+                            1>([&format_context, &value](auto i) {
+      if (i > 0) {
+        format_context.advance_to(std::format_to(format_context.out(), ", "));
+      }
+      format_context.advance_to(std::format_to(format_context.out(), "["));
+      fcarouge::for_constexpr<0, std::tuple_size_v<ColumnIndexes>,
+                              1>([&format_context, &value, i](auto j) {
+        if (j > 0) {
+          format_context.advance_to(std::format_to(format_context.out(), ", "));
+        }
+
+        using type =
+            decltype(typename std::tuple_element_t<i, RowIndexes>::type{} *
+                     typename std::tuple_element_t<j, ColumnIndexes>::type{});
+
+        auto v{value.data(int{i}, int{j})};
+
+        format_context.advance_to(std::format_to(
+            format_context.out(), "{}", v * fcarouge::identity_v<type>
+            // What's going with Eigen needing this index cast?
+            // Works, but not quite correct...
+            // * typename std::tuple_element_t<i, RowIndexes>::type{}
+            // * typename std::tuple_element_t<j, ColumnIndexes>::type{}
+            ));
+      });
+      format_context.advance_to(std::format_to(format_context.out(), "]"));
+    });
+
+    format_context.advance_to(std::format_to(format_context.out(), "]"));
+
+    return format_context.out();
+  }
+
+  template <typename OutputIterator>
+  constexpr auto format(
+      const fcarouge::physical_matrix<Matrix, RowIndexes, ColumnIndexes> &value,
+      std::basic_format_context<OutputIterator, Char> &format_context) const
+      -> OutputIterator
+    requires(std::tuple_size_v<RowIndexes> == 1 &&
+             std::tuple_size_v<ColumnIndexes> != 1)
+  {
+    format_context.advance_to(std::format_to(format_context.out(), "["));
+
+    fcarouge::for_constexpr<0, std::tuple_size_v<ColumnIndexes>, 1>(
+        [&format_context, &value](auto j) {
+          if (j > 0) {
+            format_context.advance_to(
+                std::format_to(format_context.out(), ", "));
+          }
+
+          format_context.advance_to(std::format_to(
+              format_context.out(), "{}",
+              value.data(j) *
+                  typename std::tuple_element_t<0, RowIndexes>::type{} *
+                  typename std::tuple_element_t<j, ColumnIndexes>::type{}));
+        });
+
+    format_context.advance_to(std::format_to(format_context.out(), "]"));
+
+    return format_context.out();
+  }
+
+  template <typename OutputIterator>
+  constexpr auto format(
+      const fcarouge::physical_matrix<Matrix, RowIndexes, ColumnIndexes> &value,
+      std::basic_format_context<OutputIterator, Char> &format_context) const
+      -> OutputIterator
+    requires(std::tuple_size_v<RowIndexes> == 1 &&
+             std::tuple_size_v<ColumnIndexes> == 1)
+  {
+    format_context.advance_to(std::format_to(format_context.out(), "["));
+
+    format_context.advance_to(std::format_to(
+        format_context.out(), "{}",
+        value.data(0) * typename std::tuple_element_t<0, RowIndexes>::type{} *
+            typename std::tuple_element_t<0, ColumnIndexes>::type{}));
+
+    format_context.advance_to(std::format_to(format_context.out(), "]"));
+
+    return format_context.out();
+  }
+};
+
+#endif // FCAROUGE_PHYSICAL_LINALG_HPP
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 3bf49eea6..9863a4dc9 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -36,6 +36,32 @@ OTHER DEALINGS IN THE SOFTWARE.
 
 For more information, please refer to <https://unlicense.org> ]]
 
+foreach(BACKEND IN ITEMS "eigen")
+  foreach(SAMPLE "units_kf_6x2x0_vehicle_location.cpp")
+    get_filename_component(NAME ${SAMPLE} NAME_WE)
+    add_executable(kalman_sample_${BACKEND}_${NAME}_driver ${SAMPLE})
+    target_link_libraries(
+      kalman_sample_${BACKEND}_${NAME}_driver
+      PRIVATE kalman kalman_main kalman_linalg_${BACKEND} kalman_options
+              kalman_physical_linalg_mp_units_eigen)
+    separate_arguments(TEST_COMMAND UNIX_COMMAND $ENV{COMMAND})
+    add_test(NAME kalman_sample_${BACKEND}_${NAME}
+             COMMAND ${TEST_COMMAND}
+                     $<TARGET_FILE:kalman_sample_${BACKEND}_${NAME}_driver>)
+  endforeach()
+endforeach()
+return() # REMOVE ME
+foreach(TEST "units_kf_1x1x0_building_height.cpp")
+  get_filename_component(NAME ${TEST} NAME_WE)
+  add_executable(kalman_test_${NAME}_driver ${TEST})
+  target_link_libraries(
+    kalman_test_${NAME}_driver PRIVATE kalman kalman_main kalman_options
+                                       kalman_unit_mp_units)
+  separate_arguments(TEST_COMMAND UNIX_COMMAND $ENV{COMMAND})
+  add_test(NAME kalman_test_${NAME}
+           COMMAND ${TEST_COMMAND} $<TARGET_FILE:kalman_test_${NAME}_driver>)
+endforeach()
+
 foreach(
   TEST
   "kalman_constructor_default_float_1x1x1.cpp"
diff --git a/test/units_kf_1x1x0_building_height.cpp b/test/units_kf_1x1x0_building_height.cpp
new file mode 100644
index 000000000..056c68261
--- /dev/null
+++ b/test/units_kf_1x1x0_building_height.cpp
@@ -0,0 +1,85 @@
+/*  __          _      __  __          _   _
+| |/ /    /\   | |    |  \/  |   /\   | \ | |
+| ' /    /  \  | |    | \  / |  /  \  |  \| |
+|  <    / /\ \ | |    | |\/| | / /\ \ | . ` |
+| . \  / ____ \| |____| |  | |/ ____ \| |\  |
+|_|\_\/_/    \_\______|_|  |_/_/    \_\_| \_|
+
+Kalman Filter
+Version 0.4.0
+https://github.com/FrancoisCarouge/Kalman
+
+SPDX-License-Identifier: Unlicense
+
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <https://unlicense.org> */
+
+#include "fcarouge/kalman.hpp"
+#include "fcarouge/unit.hpp"
+
+#include <cassert>
+#include <cmath>
+
+namespace fcarouge::test {
+namespace {
+//! @test Verifies compatibility with the `mp-units` quantities and units
+//! library for C++ in the case of an arithmetic 1x1x0 filter.
+[[maybe_unused]] auto sample{[] {
+  kalman filter{state{60. * m}, output<decltype(0. * m)>,
+                estimate_uncertainty{225. * m * m},
+                output_uncertainty{25. * m * m}};
+
+  assert(60 * m == filter.x() &&
+         "Since our system's dynamic model is constant, i.e. the building "
+         "doesn't change its height: 60 meters.");
+  assert(225 * m * m == filter.p() &&
+         "The extrapolated estimate uncertainty (variance) also doesn't "
+         "change: 225");
+
+  filter.update(48.54 * m);
+
+  filter.update(47.11 * m);
+  filter.update(55.01 * m);
+  filter.update(55.15 * m);
+  filter.update(49.89 * m);
+  filter.update(40.85 * m);
+  filter.update(46.72 * m);
+  filter.update(50.05 * m);
+  filter.update(51.27 * m);
+  filter.update(49.95 * m);
+
+  assert(abs(1 - filter.x() / (49.57 * m)) < 0.001 &&
+         "After 10 measurement and update iterations, the building estimated "
+         "height is: 49.57m.");
+
+  // std::println("{}", filter);
+  // {"f": 1 m², "k": 0.09890109890109894, "p": 2.4725274725274726 m², "r": 25
+  // m², "s": 27.743902439024392 m², "x": 49.5698901098901 m, "y":
+  // 0.4218292682926972 m, "z": 49.95 m}
+
+  return 0;
+}()};
+} // namespace
+} // namespace fcarouge::test
diff --git a/test/units_kf_6x2x0_vehicle_location.cpp b/test/units_kf_6x2x0_vehicle_location.cpp
new file mode 100644
index 000000000..343e06f23
--- /dev/null
+++ b/test/units_kf_6x2x0_vehicle_location.cpp
@@ -0,0 +1,170 @@
+/*  __          _      __  __          _   _
+| |/ /    /\   | |    |  \/  |   /\   | \ | |
+| ' /    /  \  | |    | \  / |  /  \  |  \| |
+|  <    / /\ \ | |    | |\/| | / /\ \ | . ` |
+| . \  / ____ \| |____| |  | |/ ____ \| |\  |
+|_|\_\/_/    \_\______|_|  |_/_/    \_\_| \_|
+
+Kalman Filter
+Version 0.4.0
+https://github.com/FrancoisCarouge/Kalman
+
+SPDX-License-Identifier: Unlicense
+
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <https://unlicense.org> */
+
+#include "fcarouge/kalman.hpp"
+#include "fcarouge/physical_linalg.hpp"
+#include "fcarouge/unit.hpp"
+
+#include <cassert>
+#include <format>
+#include <print>
+
+namespace fcarouge::test {
+namespace {
+// The strongly typed unit index for the physical linear algebra.
+// Do we need this?
+template <typename Quantity> struct index {
+  using type = Quantity;
+
+  // Strong strongly typed types prevernt conversion...
+  [[nodiscard]] static constexpr auto convert(const auto &value) {
+    return value.numerical_value_in(value.unit);
+  }
+};
+
+using scalar = double;
+
+template <typename... RowIndexes>
+using vector =
+    physical_column_vector<column_vector<scalar, sizeof...(RowIndexes)>,
+                           RowIndexes...>;
+
+template <typename... RowIndexes>
+inline auto output{fcarouge::output<vector<RowIndexes...>>};
+
+using distance = index<distance_t<scalar>>;
+using velocity = index<velocity_t<scalar>>;
+using acceleration = index<acceleration_t<scalar>>;
+
+using state_t =
+    vector<distance, velocity, acceleration, distance, velocity, acceleration>;
+using output_t = vector<distance, distance>;
+using estimate_uncertainty_t = deduce_matrix<state_t, state_t>;
+using process_uncertainty_t = estimate_uncertainty_t;
+using output_uncertainty_t = deduce_matrix<output_t, output_t>;
+using output_model_t = deduce_matrix<output_t, state_t>;
+using state_transition_t = estimate_uncertainty_t;
+
+using state = fcarouge::state<state_t>;
+using estimate_uncertainty =
+    fcarouge::estimate_uncertainty<estimate_uncertainty_t>;
+using process_uncertainty =
+    fcarouge::process_uncertainty<process_uncertainty_t>;
+using output_uncertainty = fcarouge::output_uncertainty<output_uncertainty_t>;
+using output_model = fcarouge::output_model<output_model_t>;
+using state_transition = fcarouge::state_transition<state_transition_t>;
+
+//! @brief Estimating the vehicle location.
+//!
+//! @details See the sample for details.
+[[maybe_unused]] auto test{[] {
+  kalman filter{
+      state{0. * m, 0. * m / s, 0. * m / s2, 0. * m, 0. * m / s, 0. * m / s2},
+      output<distance, distance>,
+      estimate_uncertainty{500. * identity_v<estimate_uncertainty_t>},
+      process_uncertainty{// 0.2 * 0.2 *
+                          // matrix<6, 6>{{0.25, 0.5, 0.5, 0., 0., 0.},
+                          //              {0.5, 1., 1., 0., 0., 0.},
+                          //              {0.5, 1., 1., 0., 0., 0.},
+                          //              {0., 0., 0., 0.25, 0.5, 0.5},
+                          //              {0., 0., 0., 0.5, 1., 1.},
+                          //              {0., 0., 0., 0.5, 1., 1.}}
+                          identity_v<process_uncertainty_t>},
+      output_uncertainty{{9. * m2, 0. * m2}, {0. * m2, 9. * m2}},
+      output_model{
+          // {1. * m2, 0. * m2 / s, 0. * m2 / s2, 0. * m2, 0. * m2 / s, 0. * m2
+          // / s2},
+          // {0. * m2, 0. * m2 / s, 0. * m2 / s2, 1. * m2, 0. * m2 / s, 0. * m2
+          // / s2}
+          identity_v<output_model_t>},
+      state_transition{// {1., 1., 0.5, 0., 0., 0.},
+                       // {0., 1., 1., 0., 0., 0.},
+                       // {0., 0., 1., 0., 0., 0.},
+                       // {0., 0., 0., 1., 1., 0.5},
+                       // {0., 0., 0., 0., 1., 1.},
+                       // {0., 0., 0., 0., 0., 1.}}
+                       identity_v<state_transition_t>}};
+
+  std::println("{}", filter);
+
+  filter.predict();
+  filter.update(-393.66 * m, 300.4 * m);
+  filter.predict();
+  filter.update(-375.93 * m, 301.78 * m);
+  filter.predict();
+
+  std::println("{}", filter);
+
+  // // Verify the example estimated state at 0.1% accuracy.
+  // assert(std::abs(1 - filter.x()[0] / -277.8 * m) < 0.001 &&
+  //        std::abs(1 - filter.x()[1] / 148.3 * m / s) < 0.001 &&
+  //        std::abs(1 - filter.x()[2] / 94.5 * m / s2) < 0.001 &&
+  //        std::abs(1 - filter.x()[3] / 249.8 * m) < 0.001 &&
+  //        std::abs(1 - filter.x()[4] / -85.9 * m / s) < 0.001 &&
+  //        std::abs(1 - filter.x()[5] / -63.62 * m / s2) < 0.001 &&
+  //        "The state estimates expected at 0.1% accuracy.");
+
+  return 0;
+}()};
+} // namespace
+} // namespace fcarouge::test
+
+// template <typename Quantity, typename Char>
+// // It is allowed to add template specializations for any standard library
+// class
+// // template to the namespace std only if the declaration depends on at least
+// one
+// // program-defined type and the specialization satisfies all requirements for
+// // the original template, except where such specializations are prohibited.
+// // NOLINTNEXTLINE(cert-dcl58-cpp)
+// struct std::formatter<fcarouge::test::index<Quantity>, Char> {
+//   constexpr auto parse(std::basic_format_parse_context<Char> &parse_context)
+//   {
+//     return parse_context.begin();
+//   }
+
+//   template <typename OutputIterator>
+//   constexpr auto
+//   format(const fcarouge::test::index<Quantity> &value,
+//          std::basic_format_context<OutputIterator, Char> &format_context)
+//          const
+//       -> OutputIterator {
+
+//     return std::format_to(format_context.out(), "{}", value.quantity);
+//   }
+// };