[cicd] use stable clang 14 while 15 broken (#311)

* [cicd] use stable clang 14 while 15 broken

Author: FrancoisCarouge

.github/workflows/clang_tidy.yml

@@ -14,9 +14,6 @@ jobs:
       uses: actions/checkout@v3.1.0
     - name: Install
       run: |
-        wget https://apt.llvm.org/llvm.sh
-        chmod +x llvm.sh
-        sudo ./llvm.sh 15 all
         ( cd /tmp
           git clone --depth 1 "https://gitlab.com/libeigen/eigen"
           cmake -S "eigen" -B "eigen/build"
@@ -40,7 +37,7 @@ jobs:
     - name: Verify
       run: |
         FILES="include/fcarouge/kalman.hpp benchmark/include/benchmark.hpp"
-        clang-tidy-15 ${FILES} --warnings-as-errors=* -- \
+        clang-tidy-14 ${FILES} --warnings-as-errors=* -- \
           -x c++ -Iinclude \
           -I/usr/local/include/eigen3 \
           -Isupport \

.github/workflows/format.yml

@@ -14,12 +14,9 @@ jobs:
       uses: actions/checkout@v3
     - name: "Install"
       run: |
-        wget https://apt.llvm.org/llvm.sh
-        chmod +x llvm.sh
-        sudo ./llvm.sh 15 all
         pip install cmakelang
     - name: "Test"
       run: |
         find . -iname "*.hpp" -o -iname "*.tpp" -o -iname "*.cpp" -o -iwholename "./support/format" | xargs \
-          clang-format-15 --Werror --dry-run --verbose -style=file
+          clang-format-14 --Werror --dry-run --verbose -style=file
         cmake-format --check CMakeLists.txt

include/fcarouge/internal/kalman.tpp

@@ -81,16 +81,15 @@ template <typename State, typename Output, typename Input, typename UpdateTypes,
             "discarded.")]] inline constexpr auto
 kalman<State, Output, Input, UpdateTypes, PredictionTypes>::u() const
     -> const input &requires(not std::is_same_v<Input, void>) {
-                      return filter.u;
-                    }
+  return filter.u;
+}
 
 template <typename State, typename Output, typename Input, typename UpdateTypes,
           typename PredictionTypes>
 [[nodiscard("The returned estimated covariance matrix P is unexpectedly "
-            "discarded.")]] inline constexpr auto kalman<State, Output, Input,
-                                                         UpdateTypes,
-                                                         PredictionTypes>::p()
-    const -> const estimate_uncertainty & {
+            "discarded.")]] inline constexpr auto
+kalman<State, Output, Input, UpdateTypes, PredictionTypes>::p() const
+    -> const estimate_uncertainty & {
   return filter.p;
 }
 
@@ -245,26 +244,24 @@ template <typename State, typename Output, typename Input, typename UpdateTypes,
             "discarded.")]] inline constexpr auto
 kalman<State, Output, Input, UpdateTypes, PredictionTypes>::g() const
     -> const input_control &requires(not std::is_same_v<Input, void>) {
-                              return filter.g;
-                            }
+  return filter.g;
+}
 
 template <typename State, typename Output, typename Input, typename UpdateTypes,
           typename PredictionTypes>
 [[nodiscard("The returned control transition matrix G is unexpectedly "
-            "discarded.")]] inline constexpr auto kalman<State, Output, Input,
-                                                         UpdateTypes,
-                                                         PredictionTypes>::g()
+            "discarded.")]] inline constexpr auto
+kalman<State, Output, Input, UpdateTypes, PredictionTypes>::g()
     -> input_control &requires(not std::is_same_v<Input, void>) {
-                        return filter.g;
-                      }
+  return filter.g;
+}
 
 template <typename State, typename Output, typename Input, typename UpdateTypes,
           typename PredictionTypes>
-inline constexpr void kalman<State, Output, Input, UpdateTypes,
-                             PredictionTypes>::g(const auto &value,
-                                                 const auto &...values)
-  requires(not std::is_same_v<Input, void>)
-{
+inline constexpr void
+kalman<State, Output, Input, UpdateTypes, PredictionTypes>::g(
+    const auto &value,
+    const auto &...values) requires(not std::is_same_v<Input, void>) {
   if constexpr (std::is_convertible_v<decltype(value), input_control>) {
     filter.g = std::move(input_control{value, values...});
   } else {

include/fcarouge/internal/utility.hpp

@@ -48,8 +48,7 @@ template <typename Type>
 concept arithmetic = std::integral<Type> || std::floating_point<Type>;
 
 template <typename Type>
-concept algebraic = not
-arithmetic<Type>;
+concept algebraic = not arithmetic<Type>;
 
 struct empty {
   inline constexpr explicit empty([[maybe_unused]] auto &&...any) noexcept {
@@ -61,9 +60,7 @@ template <typename...> struct pack {};
 
 using empty_pack = pack<>;
 
-template <typename Type> struct repack {
-  using type = Type;
-};
+template <typename Type> struct repack { using type = Type; };
 
 template <template <typename...> typename From, typename... Types>
 struct repack<From<Types...>> {
@@ -92,7 +89,7 @@ template <arithmetic Arithmetic>
 inline constexpr Arithmetic identity_v<Arithmetic>{1};
 
 template <typename Matrix>
-  requires requires(Matrix value) { value.Identity(); }
+requires requires(Matrix value) { value.Identity(); }
 inline const auto identity_v<Matrix>{Matrix::Identity()};
 
 template <typename Type>
@@ -104,7 +101,7 @@ template <arithmetic Arithmetic>
 inline constexpr Arithmetic zero_v<Arithmetic>{0};
 
 template <typename Matrix>
-  requires requires(Matrix value) { value.Zero(); }
+requires requires(Matrix value) { value.Zero(); }
 inline const auto zero_v<Matrix>{Matrix::Zero()};
 
 struct transpose final {
@@ -115,7 +112,7 @@ struct transpose final {
   }
 
   template <typename Matrix>
-    requires requires(Matrix value) { value.transpose(); }
+  requires requires(Matrix value) { value.transpose(); }
   [[nodiscard]] inline constexpr auto operator()(const Matrix &value) const {
     return value.transpose();
   }
@@ -139,22 +136,22 @@ struct deducer final {
 
   // Eigen's types deductions.
   template <typename Lhs, typename Rhs>
-    requires requires(Lhs lhs, Rhs rhs) {
-               typename Lhs::PlainMatrix;
-               typename Lhs::PlainMatrix;
-             }
+  requires requires(Lhs lhs, Rhs rhs) {
+    typename Lhs::PlainMatrix;
+    typename Lhs::PlainMatrix;
+  }
   [[nodiscard]] inline constexpr auto operator()(const Lhs &lhs,
                                                  const Rhs &rhs) const ->
       typename decltype(lhs * rhs.transpose())::PlainMatrix;
 
   template <typename Lhs, arithmetic Rhs>
-    requires requires(Lhs lhs) { typename Lhs::PlainMatrix; }
+  requires requires(Lhs lhs) { typename Lhs::PlainMatrix; }
   [[nodiscard]] inline constexpr auto operator()(const Lhs &lhs,
                                                  const Rhs &rhs) const ->
       typename Lhs::PlainMatrix;
 
   template <arithmetic Lhs, typename Rhs>
-    requires requires(Rhs rhs) { typename Rhs::PlainMatrix; }
+  requires requires(Rhs rhs) { typename Rhs::PlainMatrix; }
   [[nodiscard]] inline constexpr auto operator()(const Lhs &lhs,
                                                  const Rhs &rhs) const ->
       typename decltype(rhs.transpose())::PlainMatrix;

include/fcarouge/kalman.hpp

@@ -518,8 +518,9 @@ class kalman final {
   //! control transition matrix G.
   //!
   //! @complexity Constant.
-  inline constexpr void g(const auto &value, const auto &...values)
-    requires(not std::is_same_v<Input, void>);
+  inline constexpr void
+  g(const auto &value,
+    const auto &...values) requires(not std::is_same_v<Input, void>);
 
   //! @brief Returns the gain matrix K.
   //!