[linalg] cleanup and hygiene

Author: FrancoisCarouge

linalg/naive/fcarouge/linalg.hpp

@@ -46,7 +46,7 @@ For more information, please refer to <https://unlicense.org> */
 
 #include "fcarouge/utility.hpp"
 
-#include <initializer_list>
+#include <algorithm>
 
 namespace fcarouge {
 //! @name Algebraic Types
@@ -70,57 +70,48 @@ template <typename Type = double, auto Row = 1, auto Column = 1> struct matrix {
 
   inline constexpr matrix &operator=(matrix &&other) = default;
 
-  inline constexpr explicit(false) matrix(Type element)
-    requires(Row == 1 && Column == 1)
-  {
-    data[0][0] = element;
-  }
+  inline constexpr matrix(const std::same_as<Type> auto &...elements)
+    requires(Row == 1 && sizeof...(elements) == Column)
+      : data{{elements...}} {}
 
-  inline constexpr explicit matrix(Type(element)[1])
-    requires(Row == 1 && Column == 1)
+  inline constexpr matrix(const std::same_as<Type> auto &...elements)
+    requires(Row != 1 && Column == 1 && sizeof...(elements) == Row)
   {
-    data[0][0] = element[0];
+    decltype(Row) i{0};
+    ([&] { data[i++][0] = elements; }(), ...);
   }
 
-  inline constexpr explicit matrix(Type(column)[Row])
-    requires(Row != 1 && Column == 1)
+  // Combine?
+  inline constexpr explicit matrix(Type (&elements)[Column])
+    requires(Row == 1)
   {
-    for (decltype(Row) i{0}; i < Row; ++i) {
-      data[i][0] = column[i];
+    for (decltype(Column) j{0}; j < Column; ++j) {
+      data[0][j] = elements[j];
     }
   }
 
-  inline constexpr explicit matrix(Type(row)[Column])
-    requires(Row == 1 && Column != 1)
+  inline constexpr explicit matrix(Type (&elements)[Row])
+    requires(Row != 1 && Column == 1)
   {
-    for (decltype(Column) j{0}; j < Column; ++j) {
-      data[0][j] = row[j];
+    for (decltype(Row) i{0}; i < Row; ++i) {
+      data[i][0] = elements[i];
     }
   }
 
-  inline constexpr matrix(const auto &...elements)
-    requires(Row != 1 && Column == 1 && sizeof...(elements) == Row)
+  template <typename... Types, auto... Columns>
+  matrix(const Types (&...rows)[Columns])
+    requires(std::conjunction_v<std::is_same<Type, Types>...> &&
+             ((Columns == Column) && ... && true))
   {
     decltype(Row) i{0};
-    ([&] { data[i++][0] = elements; }(), ...);
-  }
-
-  inline constexpr matrix(const auto &...elements)
-    requires(Row == 1 && Column != 1 && sizeof...(elements) == Column)
-  {
-    decltype(Column) j{0};
-    ([&] { data[0][j++] = elements; }(), ...);
-  }
-
-  inline constexpr explicit matrix(
-      const std::initializer_list<std::initializer_list<Type>> &rows) {
-    // static_assert
-    for (decltype(Row) i{0}; auto &&elements : rows) {
-      for (decltype(Column) j{0}; auto &&element : elements) {
-        data[i][j++] = element;
-      }
-      ++i;
-    }
+    (
+        [&] {
+          for (decltype(Column) j{0}; auto &&element : rows) {
+            data[i][j++] = element;
+          }
+          ++i;
+        }(),
+        ...);
   }
 
   [[nodiscard]] inline constexpr explicit(false) operator Type() const
@@ -158,10 +149,6 @@ template <typename Type = double, auto Row = 1, auto Column = 1> struct matrix {
     return data[row][column];
   }
 
-  [[nodiscard]] inline constexpr bool operator==(const matrix &other) const
-    requires(Row != 1 || Column != 1)
-  = default;
-
   [[no_unique_address]] Type data[Row][Column]{};
 };
 
@@ -345,6 +332,21 @@ transpose(const matrix<Type, Row, Column> &lhs) {
 
   return result;
 }
+
+template <typename Type, auto Row, auto Column>
+[[nodiscard]] inline constexpr bool
+operator==(const matrix<Type, Row, Column> &lhs,
+           const matrix<Type, Row, Column> &rhs) {
+  for (decltype(Row) i{0}; i < Row; ++i) {
+    for (decltype(Column) j{0}; j < Column; ++j) {
+      if (lhs.data[i][j] != rhs.data[i][j]) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
 } // namespace fcarouge
 
 #endif // FCAROUGE_LINALG_HPP