diff --git a/include/fcarouge/internal/eigen.hpp b/include/fcarouge/internal/eigen.hpp
index cd37c4b43d..3d8ac5efcd 100644
--- a/include/fcarouge/internal/eigen.hpp
+++ b/include/fcarouge/internal/eigen.hpp
@@ -60,6 +60,23 @@ namespace fcarouge::eigen::internal
 template <typename Type>
 concept arithmetic = std::integral<Type> || std::floating_point<Type>;
 
+[[nodiscard]] inline constexpr auto matrix(const auto &value)
+{
+  return value;
+}
+
+[[nodiscard]] inline constexpr auto matrix(const arithmetic auto &value)
+{
+  using type = std::decay_t<decltype(value)>;
+  return Eigen::Matrix<type, 1, 1>{ value };
+}
+
+template <typename Type, std::size_t Size>
+[[nodiscard]] inline constexpr auto matrix(const std::array<Type, Size> &value)
+{
+  return Eigen::Matrix<Type, Size, 1>{ value.data() };
+}
+
 //! @brief Function object for performing Eigen matrix transposition.
 //!
 //! @details Implemented with the Eigen linear algebra library matrices with
@@ -70,23 +87,19 @@ struct transpose {
   //! @param value Value to compute the transpose of.
   //!
   //! @exception May throw implementation-defined exceptions.
-  [[nodiscard]] inline constexpr auto operator()(const auto &value) const
+  [[nodiscard]] inline constexpr auto operator()(const auto &value) const ->
+      typename Eigen::Matrix<typename std::decay_t<decltype(value)>::Scalar,
+                             std::decay_t<decltype(value)>::ColsAtCompileTime,
+                             std::decay_t<decltype(value)>::RowsAtCompileTime>
   {
-    using type = std::decay_t<decltype(value)>;
-    using result_type =
-        typename Eigen::Matrix<typename type::Scalar, type::ColsAtCompileTime,
-                               type::RowsAtCompileTime>;
-
-    return result_type{ value.transpose() };
+    return value.transpose();
   }
 
   //! @brief Returns the transpose of `value`.
   //!
   //! @param value Value to compute the transpose of.
-  //!
-  //! @todo Can this be optimized?
   [[nodiscard]] inline constexpr auto
-  operator()(const arithmetic auto &value) const
+  operator()(const arithmetic auto &value) const noexcept -> const auto &
   {
     return value;
   }
@@ -102,22 +115,20 @@ struct symmetrize {
   //! @param value Value to compute the symmetry of.
   //!
   //! @exception May throw implementation-defined exceptions.
+  //!
+  //! @todo Should overflow be protected?
   [[nodiscard]] inline constexpr auto operator()(const auto &value) const
   {
-    using result_type = std::decay_t<decltype(value)>;
-
-    return result_type{ (value + value.transpose()) / 2 };
+    return (value + value.transpose()) / 2;
   }
 
   //! @brief Returns the symmetrized `value`.
   //!
   //! @param value Value to compute the symmetry of.
-  //!
-  //! @todo Can this be optimized?
   [[nodiscard]] inline constexpr auto
-  operator()(const arithmetic auto &value) const
+  operator()(arithmetic auto &&value) const noexcept -> auto &&
   {
-    return value;
+    return std::forward(value);
   }
 };
 
@@ -134,83 +145,17 @@ struct divide {
   //! @return The quotient matrix. Q: m x o
   //!
   //! @exception May throw implementation-defined exceptions.
-  //!
-  //! @todo Why compilation fails if we specify the return type in the body of
-  //! the function?
   template <typename Numerator, typename Denominator>
   [[nodiscard]] inline constexpr auto
   operator()(const Numerator &numerator, const Denominator &denominator) const
-      -> typename Eigen::Matrix<typename std::decay_t<Numerator>::Scalar,
-                                std::decay_t<Numerator>::RowsAtCompileTime,
-                                std::decay_t<Denominator>::RowsAtCompileTime>
-  {
-    return denominator.transpose()
-        .fullPivHouseholderQr()
-        .solve(numerator.transpose())
-        .transpose();
-  }
-
-  //! @brief Returns the quotient of `numerator` and `denominator`.
-  //!
-  //! @param numerator The dividend matrix of the division. N: m x 1
-  //! @param denominator The divisor value of the division.
-  //!
-  //! @return The quotient column vector. Q: m x 1
-  //!
-  //! @exception May throw implementation-defined exceptions.
-  //!
-  //! @todo Simplify implementation.
-  template <typename Numerator>
-  [[nodiscard]] inline constexpr auto
-  operator()(const Numerator &numerator,
-             const arithmetic auto &denominator) const ->
-      typename Eigen::Vector<typename std::decay_t<Numerator>::Scalar,
-                             std::decay_t<Numerator>::RowsAtCompileTime>
-  {
-    return Eigen::Matrix<typename std::decay_t<Numerator>::Scalar, 1, 1>{
-      denominator
-    }
-        .transpose()
-        .fullPivHouseholderQr()
-        .solve(numerator.transpose())
-        .transpose();
-  }
-
-  //! @brief Returns the quotient of `numerator` and `denominator`.
-  //!
-  //! @param numerator The dividend value of the division.
-  //! @param denominator The divisor matrix of the division. D: o x 1
-  //!
-  //! @return The quotient row vector. Q: 1 x o
-  //!
-  //! @exception May throw implementation-defined exceptions.
-  //!
-  //! @todo Simplify implementation.
-  template <typename Denominator>
-  [[nodiscard]] inline constexpr auto
-  operator()(const arithmetic auto &numerator,
-             const Denominator &denominator) const ->
-      typename Eigen::RowVector<typename std::decay_t<Denominator>::Scalar,
-                                std::decay_t<Denominator>::RowsAtCompileTime>
   {
-    return denominator.transpose()
-        .fullPivHouseholderQr()
-        .solve(Eigen::Matrix<typename std::decay_t<decltype(numerator)>::Scalar,
-                             1, 1>{ numerator })
-        .transpose();
-  }
+    auto result{ matrix(denominator)
+                     .transpose()
+                     .fullPivHouseholderQr()
+                     .solve(matrix(numerator).transpose())
+                     .transpose() };
 
-  //! @brief Returns the quotient of `numerator` and `denominator`.
-  //!
-  //! @param numerator The dividend value of the division.
-  //! @param denominator The divisor value of the division.
-  //!
-  //! @return The quotient value.
-  [[nodiscard]] inline constexpr auto
-  operator()(const arithmetic auto &numerator,
-             const arithmetic auto &denominator) const
-  {
-    return numerator / denominator;
+    return typename decltype(result)::PlainMatrix{ result };
   }
 };
 
@@ -230,7 +175,7 @@ struct identity_matrix {
   //!
   //! @exception May throw implementation-defined exceptions.
   template <typename Type>
-  [[nodiscard]] inline constexpr auto operator()() const
+  [[nodiscard]] inline constexpr auto operator()() const -> Type
   {
     return Type::Identity();
   }
@@ -241,9 +186,9 @@ struct identity_matrix {
   //!
   //! @return The value `1`.
   template <arithmetic Type>
-  [[nodiscard]] inline constexpr auto operator()() const noexcept
+  [[nodiscard]] inline constexpr auto operator()() const noexcept -> Type
   {
-    return Type{ 1 };
+    return 1;
   }
 };
 
@@ -254,14 +199,9 @@ template <typename Type = double, std::size_t State = 1, std::size_t Output = 1,
           std::size_t Input = 1,
           typename UpdateTypes = fcarouge::internal::empty_pack_t,
           typename PredictionTypes = fcarouge::internal::empty_pack_t>
-using kalman = fcarouge::kalman<
-    std::conditional_t<State == 1, Type, Eigen::Vector<Type, State>>,
-    std::conditional_t<Output == 1, Type, Eigen::Vector<Type, Output>>,
-    std::conditional_t<
-        Input == 0, void,
-        std::conditional_t<Input == 1, Type, Eigen::Vector<Type, Input>>>,
-    transpose, symmetrize, divide, identity_matrix, UpdateTypes,
-    PredictionTypes>;
+using kalman =
+    fcarouge::kalman<Type, State, Output, Input, transpose, symmetrize, divide,
+                     identity_matrix, UpdateTypes, PredictionTypes>;
 
 } // namespace fcarouge::eigen::internal
 
diff --git a/include/fcarouge/internal/format.hpp b/include/fcarouge/internal/format.hpp
index acfad1c0b2..2e4492d4f7 100644
--- a/include/fcarouge/internal/format.hpp
+++ b/include/fcarouge/internal/format.hpp
@@ -43,17 +43,19 @@ For more information, please refer to <https://unlicense.org> */
 
 namespace fcarouge
 {
-template <typename State, typename Output, typename Input, typename Transpose,
-          typename Symmetrize, typename Divide, typename Identity,
-          typename UpdateTypes, typename PredictionTypes>
+template <typename Type, std::size_t State, std::size_t Output,
+          std::size_t Input, typename Transpose, typename Symmetrize,
+          typename Divide, typename Identity, typename UpdateTypes,
+          typename PredictionTypes>
 class kalman;
 } // namespace fcarouge
 
-template <typename State, typename Output, typename Input, typename Transpose,
-          typename Symmetrize, typename Divide, typename Identity,
-          typename UpdateTypes, typename PredictionTypes, typename Char>
+template <typename Type, std::size_t State, std::size_t Output,
+          std::size_t Input, typename Transpose, typename Symmetrize,
+          typename Divide, typename Identity, typename UpdateTypes,
+          typename PredictionTypes, typename Char>
 struct std::formatter<
-    fcarouge::kalman<State, Output, Input, Transpose, Symmetrize, Divide,
+    fcarouge::kalman<Type, State, Output, Input, Transpose, Symmetrize, Divide,
                      Identity, UpdateTypes, PredictionTypes>,
     Char> {
   //! @todo Support parsing arguments.
@@ -64,7 +66,7 @@ struct std::formatter<
 
   // @todo How to support different nested types?
   template <typename OutputIt>
-  auto format(const fcarouge::kalman<State, Output, Input, Transpose,
+  auto format(const fcarouge::kalman<Type, State, Output, Input, Transpose,
                                      Symmetrize, Divide, Identity, UpdateTypes,
                                      PredictionTypes> &filter,
               std::basic_format_context<OutputIt, Char> &format_context)
diff --git a/include/fcarouge/internal/kalman.hpp b/include/fcarouge/internal/kalman.hpp
index 953dac76bb..852e2d43b1 100644
--- a/include/fcarouge/internal/kalman.hpp
+++ b/include/fcarouge/internal/kalman.hpp
@@ -39,6 +39,8 @@ For more information, please refer to <https://unlicense.org> */
 #ifndef FCAROUGE_INTERNAL_KALMAN_HPP
 #define FCAROUGE_INTERNAL_KALMAN_HPP
 
+#include <array>
+#include <cstddef>
 #include <functional>
 #include <type_traits>
 
@@ -61,34 +63,39 @@ struct repack<From<Types...>> {
 
 template <typename From> using repack_t = typename repack<From>::type;
 
-template <typename, typename, typename, typename, typename, typename, typename,
-          typename, typename>
+template <typename, std::size_t, std::size_t, std::size_t, typename, typename,
+          typename, typename, typename, typename>
 struct kalman {
   //! @todo Support some more specializations, all, or disable others?
 };
 
-template <typename State, typename Output, typename Transpose,
-          typename Symmetrize, typename Divide, typename Identity,
-          typename... UpdateTypes, typename... PredictionTypes>
-struct kalman<State, Output, void, Transpose, Symmetrize, Divide, Identity,
+template <typename Type, std::size_t State, std::size_t Output,
+          typename Transpose, typename Symmetrize, typename Divide,
+          typename Identity, typename... UpdateTypes,
+          typename... PredictionTypes>
+struct kalman<Type, State, Output, 0, Transpose, Symmetrize, Divide, Identity,
               pack<UpdateTypes...>, pack<PredictionTypes...>> {
   struct empty {
   };
-  using state = State;
-  using output = Output;
+  template <typename Row, typename Column>
+  using matrix = std::decay_t<std::invoke_result_t<Divide, Row, Column>>;
+  template <std::size_t Size>
+  using array = std::conditional_t<
+      Size == 1, Type,
+      std::decay_t<std::invoke_result_t<
+          Divide, std::conditional_t<Size == 1, Type, std::array<Type, Size>>,
+          Type>>>;
+  using value_type = Type;
+  using state = array<State>;
+  using output = array<Output>;
   using input = empty;
-  using estimate_uncertainty =
-      std::decay_t<std::invoke_result_t<Divide, State, State>>;
-  using process_uncertainty =
-      std::decay_t<std::invoke_result_t<Divide, State, State>>;
-  using output_uncertainty =
-      std::decay_t<std::invoke_result_t<Divide, Output, Output>>;
-  using state_transition =
-      std::decay_t<std::invoke_result_t<Divide, State, State>>;
-  using output_model =
-      std::decay_t<std::invoke_result_t<Divide, Output, State>>;
+  using estimate_uncertainty = matrix<state, state>;
+  using process_uncertainty = matrix<state, state>;
+  using output_uncertainty = matrix<output, output>;
+  using state_transition = matrix<state, state>;
+  using output_model = matrix<output, state>;
   using input_control = empty;
-  using gain = std::decay_t<std::invoke_result_t<Transpose, output_model>>;
+  using gain = matrix<state, output>;
   using innovation = output;
   using innovation_uncertainty = output_uncertainty;
   using observation_state_function =
@@ -106,23 +113,24 @@ struct kalman<State, Output, void, Transpose, Symmetrize, Divide, Identity,
       std::function<output(const state &, const UpdateTypes &...arguments)>;
 
   //! @todo Is there a simpler way to initialize to the zero matrix?
-  state x{ 0 * Identity().template operator()<state>() };
+  state x{ value_type{ 0 } * Identity().template operator()<state>() };
   estimate_uncertainty p{
     Identity().template operator()<estimate_uncertainty>()
   };
   process_uncertainty q{
-    0 * Identity().template operator()<process_uncertainty>()
+    value_type{ 0 } * Identity().template operator()<process_uncertainty>()
   };
-  output_uncertainty r{ 0 *
+  output_uncertainty r{ value_type{ 0 } *
                         Identity().template operator()<output_uncertainty>() };
   output_model h{ Identity().template operator()<output_model>() };
   state_transition f{ Identity().template operator()<state_transition>() };
   gain k{ Identity().template operator()<gain>() };
-  innovation y{ 0 * Identity().template operator()<innovation>() };
+  innovation y{ value_type{ 0 } *
+                Identity().template operator()<innovation>() };
   innovation_uncertainty s{
     Identity().template operator()<innovation_uncertainty>()
   };
-  output z{ 0 * Identity().template operator()<output>() };
+  output z{ value_type{ 0 } * Identity().template operator()<output>() };
 
   //! @todo Should we pass through the reference to the state x or have the user
   //! access it through k.x() when needed? Where does the practical/performance
@@ -218,27 +226,31 @@ struct kalman<State, Output, void, Transpose, Symmetrize, Divide, Identity,
   }
 };
 
-template <typename State, typename Output, typename Input, typename Transpose,
-          typename Symmetrize, typename Divide, typename Identity,
-          typename... UpdateTypes, typename... PredictionTypes>
-struct kalman<State, Output, Input, Transpose, Symmetrize, Divide, Identity,
-              pack<UpdateTypes...>, pack<PredictionTypes...>> {
-  using state = State;
-  using output = Output;
-  using input = Input;
-  using estimate_uncertainty =
-      std::decay_t<std::invoke_result_t<Divide, State, State>>;
-  using process_uncertainty =
-      std::decay_t<std::invoke_result_t<Divide, State, State>>;
-  using output_uncertainty =
-      std::decay_t<std::invoke_result_t<Divide, Output, Output>>;
-  using state_transition =
-      std::decay_t<std::invoke_result_t<Divide, State, State>>;
-  using output_model =
-      std::decay_t<std::invoke_result_t<Divide, Output, State>>;
-  using input_control =
-      std::decay_t<std::invoke_result_t<Divide, State, Input>>;
-  using gain = std::decay_t<std::invoke_result_t<Transpose, output_model>>;
+template <typename Type, std::size_t State, std::size_t Output,
+          std::size_t Input, typename Transpose, typename Symmetrize,
+          typename Divide, typename Identity, typename... UpdateTypes,
+          typename... PredictionTypes>
+struct kalman<Type, State, Output, Input, Transpose, Symmetrize, Divide,
+              Identity, pack<UpdateTypes...>, pack<PredictionTypes...>> {
+  template <typename Row, typename Column>
+  using matrix = std::decay_t<std::invoke_result_t<Divide, Row, Column>>;
+  template <std::size_t Size>
+  using array = std::conditional_t<
+      Size == 1, Type,
+      std::decay_t<std::invoke_result_t<
+          Divide, std::conditional_t<Size == 1, Type, std::array<Type, Size>>,
+          Type>>>;
+  using value_type = Type;
+  using state = array<State>;
+  using output = array<Output>;
+  using input = array<Input>;
+  using estimate_uncertainty = matrix<state, state>;
+  using process_uncertainty = matrix<state, state>;
+  using output_uncertainty = matrix<output, output>;
+  using state_transition = matrix<state, state>;
+  using output_model = matrix<output, state>;
+  using input_control = matrix<state, input>;
+  using gain = matrix<state, output>;
   using innovation = output;
   using innovation_uncertainty = output_uncertainty;
   using observation_state_function =
@@ -264,18 +276,19 @@ struct kalman<State, Output, Input, Transpose, Symmetrize, Divide, Identity,
   process_uncertainty q{
     0 * Identity().template operator()<process_uncertainty>()
   };
-  output_uncertainty r{ 0 *
+  output_uncertainty r{ value_type{ 0 } *
                         Identity().template operator()<output_uncertainty>() };
   output_model h{ Identity().template operator()<output_model>() };
   state_transition f{ Identity().template operator()<state_transition>() };
   input_control g{ Identity().template operator()<input_control>() };
   gain k{ Identity().template operator()<gain>() };
-  innovation y{ 0 * Identity().template operator()<innovation>() };
+  innovation y{ value_type{ 0 } *
+                Identity().template operator()<innovation>() };
   innovation_uncertainty s{
     Identity().template operator()<innovation_uncertainty>()
   };
-  output z{ 0 * Identity().template operator()<output>() };
-  input u{ 0 * Identity().template operator()<input>() };
+  output z{ value_type{ 0 } * Identity().template operator()<output>() };
+  input u{ value_type{ 0 } * Identity().template operator()<input>() };
 
   //! @todo Should we pass through the reference to the state x or have the user
   //! access it through k.x() when needed? Where does the practical/performance
diff --git a/include/fcarouge/kalman.hpp b/include/fcarouge/kalman.hpp
index dd87d28b70..5a7c81ad17 100644
--- a/include/fcarouge/kalman.hpp
+++ b/include/fcarouge/kalman.hpp
@@ -46,6 +46,7 @@ For more information, please refer to <https://unlicense.org> */
 #include "internal/kalman.hpp"
 
 #include <concepts>
+#include <cstddef>
 #include <functional>
 #include <type_traits>
 #include <utility>
@@ -83,15 +84,16 @@ struct identity_matrix {
 //! the measurement (Z, R), the measurement function H, and if the system has
 //! control inputs (U, B). Designing a filter is as much art as science.
 //!
-//! @tparam State The type template parameter of the state column vector x.
-//! State variables can be observed (measured), or hidden variables (inferred).
-//! This is the the mean of the multivariate Gaussian.
-//! @tparam Output The type template parameter of the measurement column vector
+//! @tparam Type The filter data value type used for computation.
+//! @tparam State The non-type template size of the state column vector x. State
+//! variables can be observed (measured), or hidden variables (inferred). This
+//! is the the mean of the multivariate Gaussian.
+//! @tparam Output The non-type template size of the measurement column vector
 //! z.
-//! @tparam Input The type template parameter of the control u. A `void` input
-//! type can be used for systems with no input control to disable all of the
-//! input control features, the control transition matrix G support, and the
-//! other related computations from the filter.
+//! @tparam Input The non-type template size of the control column vector u. A
+//! `void` input type can be used for systems with no input control to disable
+//! all of the input control features, the control transition matrix G support,
+//! and the other related computations from the filter.
 //! @tparam Transpose The customization point object template parameter of the
 //! matrix transpose functor.
 //! @tparam Symmetrize The customization point object template parameter of the
@@ -153,12 +155,13 @@ struct identity_matrix {
 //! re-initializations but to what default?
 //! @todo Could the Input be void by default? Or empty?
 //! @todo Expand std::format support with standard arguments and Eigen3 types.
-template <
-    typename State = double, typename Output = State, typename Input = void,
-    typename Transpose = std::identity, typename Symmetrize = std::identity,
-    typename Divide = std::divides<void>, typename Identity = identity_matrix,
-    typename UpdateTypes = internal::empty_pack_t,
-    typename PredictionTypes = internal::empty_pack_t>
+template <typename Type = double, std::size_t State = 1, std::size_t Output = 1,
+          std::size_t Input = 0, typename Transpose = std::identity,
+          typename Symmetrize = std::identity,
+          typename Divide = std::divides<void>,
+          typename Identity = identity_matrix,
+          typename UpdateTypes = internal::empty_pack_t,
+          typename PredictionTypes = internal::empty_pack_t>
 class kalman
 {
   private:
@@ -170,8 +173,8 @@ class kalman
   //! @brief The internal implementation unpacks the parameter packs from
   //! tuple-like types which allows for multiple parameter pack deductions.
   using implementation =
-      internal::kalman<State, Output, Input, Transpose, Symmetrize, Divide,
-                       Identity, internal::repack_t<UpdateTypes>,
+      internal::kalman<Type, State, Output, Input, Transpose, Symmetrize,
+                       Divide, Identity, internal::repack_t<UpdateTypes>,
                        internal::repack_t<PredictionTypes>>;
 
   //! @}
@@ -180,6 +183,9 @@ class kalman
   //! @name Public Member Types
   //! @{
 
+  //! @brief Type of the filter scalar data.
+  using value_type = typename implementation::value_type;
+
   //! @brief Type of the state estimate column vector X.
   using state = typename implementation::state;
 
@@ -385,7 +391,7 @@ class kalman
   //! @complexity Constant.
   [[nodiscard("The returned control column vector U is unexpectedly "
               "discarded.")]] inline constexpr auto
-  u() const -> input requires(!std::is_void_v<Input>)
+  u() const -> input requires(Input > 0)
   {
     return filter.u;
   }
@@ -870,7 +876,7 @@ class kalman
   //! @complexity Constant.
   [[nodiscard("The returned control transition matrix G is unexpectedly "
               "discarded.")]] inline constexpr auto
-  g() const -> input_control requires(!std::is_void_v<Input>)
+  g() const -> input_control requires(Input > 0)
   {
     return filter.g;
   }
@@ -880,8 +886,7 @@ class kalman
   //! @param value The copied control transition matrix G.
   //!
   //! @complexity Constant.
-  inline constexpr void
-  g(const input_control &value) requires(!std::is_void_v<Input>)
+  inline constexpr void g(const input_control &value) requires(Input > 0)
   {
     filter.g = value;
   }
@@ -891,8 +896,7 @@ class kalman
   //! @param value The moved control transition matrix G.
   //!
   //! @complexity Constant.
-  inline constexpr void
-  g(input_control &&value) requires(!std::is_void_v<Input>)
+  inline constexpr void g(input_control &&value) requires(Input > 0)
   {
     filter.g = std::move(value);
   }
@@ -906,10 +910,9 @@ class kalman
   //!
   //! @complexity Constant.
   inline constexpr void g(const auto &value, const auto &...values) requires(
-      !std::is_void_v<Input> &&
-      !std::is_assignable_v<
-          typename implementation::transition_control_function,
-          std::decay_t<decltype(value)>>)
+      Input > 0 && !std::is_assignable_v<
+                       typename implementation::transition_control_function,
+                       std::decay_t<decltype(value)>>)
   {
     filter.g = std::move(input_control{ value, values... });
   }
@@ -923,10 +926,9 @@ class kalman
   //!
   //! @complexity Constant.
   inline constexpr void g(auto &&value, auto &&...values) requires(
-      !std::is_void_v<Input> &&
-      !std::is_assignable_v<
-          typename implementation::transition_control_function,
-          std::decay_t<decltype(value)>>)
+      Input > 0 && !std::is_assignable_v<
+                       typename implementation::transition_control_function,
+                       std::decay_t<decltype(value)>>)
   {
     filter.g =
         std::move(input_control{ std::forward<decltype(value)>(value),
@@ -943,7 +945,7 @@ class kalman
   //!
   //! @complexity Constant.
   inline constexpr void g(const auto &callable) requires(
-      !std::is_void_v<Input> &&
+      Input > 0 &&
       std::is_assignable_v<typename implementation::transition_control_function,
                            std::decay_t<decltype(callable)>>)
   {
@@ -960,7 +962,7 @@ class kalman
   //!
   //! @complexity Constant.
   inline constexpr void g(auto &&callable) requires(
-      !std::is_void_v<Input> &&
+      Input > 0 &&
       std::is_assignable_v<typename implementation::transition_control_function,
                            std::decay_t<decltype(callable)>>)
   {
diff --git a/sample/dog_position.cpp b/sample/dog_position.cpp
index 4d6d3c253a..3cba450903 100644
--- a/sample/dog_position.cpp
+++ b/sample/dog_position.cpp
@@ -32,7 +32,7 @@ namespace
 //!
 //! @example dog_position.cpp
 [[maybe_unused]] auto dog_position{ [] {
-  using kalman = fcarouge::kalman<double, double, double>;
+  using kalman = fcarouge::kalman<double, 1, 1, 1>;
   kalman k;
 
   // Initialization
diff --git a/support/include/fcarouge/format b/support/include/fcarouge/format
index c7b5cac2ef..ef2a14a5dc 100644
--- a/support/include/fcarouge/format
+++ b/support/include/fcarouge/format
@@ -54,11 +54,14 @@ For more information, please refer to <https://unlicense.org> */
 #include <fmt/printf.h>
 #include <fmt/xchar.h>
 
+#include <cstddef>
+
 namespace fcarouge
 {
-template <typename State, typename Output, typename Input, typename Transpose,
-          typename Symmetrize, typename Divide, typename Identity,
-          typename UpdateArguments, typename PredictionArguments>
+template <typename Type, std::size_t State, std::size_t Output,
+          std::size_t Input, typename Transpose, typename Symmetrize,
+          typename Divide, typename Identity, typename UpdateTypes,
+          typename PredictionTypes>
 class kalman;
 } // namespace fcarouge
 
@@ -102,17 +105,18 @@ template <class... Types>
 }
 } // namespace std
 
-template <typename State, typename Output, typename Input, typename Transpose,
-          typename Symmetrize, typename Divide, typename Identity,
-          typename UpdateArguments, typename PredictionArguments, typename Char>
+template <typename Type, std::size_t State, std::size_t Output,
+          std::size_t Input, typename Transpose, typename Symmetrize,
+          typename Divide, typename Identity, typename UpdateTypes,
+          typename PredictionTypes, typename Char>
 struct fmt::formatter<
-    fcarouge::kalman<State, Output, Input, Transpose, Symmetrize, Divide,
-                     Identity, UpdateArguments, PredictionArguments>,
+    fcarouge::kalman<Type, State, Output, Input, Transpose, Symmetrize, Divide,
+                     Identity, UpdateTypes, PredictionTypes>,
     Char>
         : public std::formatter<
-              fcarouge::kalman<State, Output, Input, Transpose, Symmetrize,
-                               Divide, Identity, UpdateArguments,
-                               PredictionArguments>,
+              fcarouge::kalman<Type, State, Output, Input, Transpose,
+                               Symmetrize, Divide, Identity, UpdateTypes,
+                               PredictionTypes>,
               Char> {
 };
 
diff --git a/test/format.cpp b/test/format.cpp
index 29cbeda554..825f3419c9 100644
--- a/test/format.cpp
+++ b/test/format.cpp
@@ -51,7 +51,7 @@ namespace
 //! @test Verifies formatting filters for single-dimension filters with input
 //! control.
 [[maybe_unused]] auto format111{ [] {
-  using kalman = fcarouge::kalman<double, double, double>;
+  using kalman = fcarouge::kalman<double, 1, 1, 1>;
   kalman k;
 
   assert(std::format("{}", k) ==
diff --git a/test/initialization.cpp b/test/initialization.cpp
index 055986cb61..9b3694948d 100644
--- a/test/initialization.cpp
+++ b/test/initialization.cpp
@@ -67,7 +67,7 @@ namespace
 //! @test Verifies default values are initialized for single-dimension filters
 //! with input control.
 [[maybe_unused]] auto defaults111{ [] {
-  using kalman = fcarouge::kalman<double, double, double>;
+  using kalman = fcarouge::kalman<double, 1, 1, 1>;
   kalman k;
 
   assert(k.f() == 1);