[linalg] cleanup and hygiene

Author: FrancoisCarouge

linalg/eigen/fcarouge/linalg.hpp

@@ -54,6 +54,12 @@ namespace fcarouge {
 //! @name Algebraic Types
 //! @{
 //! @brief Compile-time sized Eigen3 matrix.
+//!
+//! @details Facade for Eigen3 implementation compatibility.
+//!
+//! @tparam Type The matrix element type.
+//! @tparam Row The number of rows of the matrix.
+//! @tparam Column The number of columns of the matrix.
 template <typename Type = double, auto Row = 1, auto Column = 1>
 using matrix = Eigen::Matrix<Type, Row, Column>;
 

linalg/lazy/fcarouge/linalg.hpp

@@ -88,9 +88,9 @@ inline constexpr auto make_generator(Type element) -> std::generator<Type> {
 //! @details The matrix is a generator. A coroutine range. Lazily generated
 //! elements and computed operations. Commonalities with ranges.
 //!
-//! @tparam Type The linear algebra underlying element type.
-//! @tparam Row The number of rows.
-//! @tparam Column The number of columns.
+//! @tparam Type The matrix element type.
+//! @tparam Row The number of rows of the matrix.
+//! @tparam Column The number of columns of the matrix.
 //! @tparam Copyable Whether the instance is fully lazy or deeply clones itself
 //! on copies. Useful for named values. May not be commonly used.
 //!
@@ -161,7 +161,7 @@ struct matrix {
           (co_yield elements_copy, ...);
         }(elements...)} {}
 
-  inline constexpr matrix(Type (&elements)[Row * Column])
+  inline constexpr explicit matrix(Type (&elements)[Row * Column])
     requires(Row == 1 || Column == 1)
       : genie{make_generator(std::to_array(elements))} {}
 
@@ -211,7 +211,7 @@ struct matrix {
   }
 
   [[nodiscard]] inline constexpr Type operator[](auto index) const
-    requires(Row > 1 && Column == 1)
+    requires(Row != 1 && Column == 1)
   {
     std::array<Type, Row * Column> elements; // std::ranges::to
 
@@ -233,7 +233,7 @@ struct matrix {
   }
 
   [[nodiscard]] inline constexpr Type operator()(auto index) const
-    requires(Row > 1 && Column == 1)
+    requires(Row != 1 && Column == 1)
   {
     std::array<Type, Row * Column> elements; // std::ranges::to
 

linalg/naive/fcarouge/linalg.hpp

@@ -51,10 +51,25 @@ For more information, please refer to <https://unlicense.org> */
 namespace fcarouge {
 //! @name Algebraic Types
 //! @{
-//! @brief Matrix.
+//! @brief Naive matrix.
+//!
+//! @details An array-of-arrays naive implementation matrix. The implementation
+//! is constexpr compatible.
+//!
+//! @tparam Type The matrix element type.
+//! @tparam Row The number of rows of the matrix.
+//! @tparam Column The number of columns of the matrix.
 template <typename Type = double, auto Row = 1, auto Column = 1> struct matrix {
   inline constexpr matrix() = default;
 
+  inline constexpr matrix(const matrix &other) = default;
+
+  inline constexpr matrix &operator=(const matrix &other) = default;
+
+  inline constexpr matrix(matrix &&other) = default;
+
+  inline constexpr matrix &operator=(matrix &&other) = default;
+
   inline constexpr explicit(false) matrix(Type element)
     requires(Row == 1 && Column == 1)
   {
@@ -68,30 +83,30 @@ template <typename Type = double, auto Row = 1, auto Column = 1> struct matrix {
   }
 
   inline constexpr explicit matrix(Type(column)[Row])
-    requires(Row > 1 && Column == 1)
+    requires(Row != 1 && Column == 1)
   {
     for (decltype(Row) i{0}; i < Row; ++i) {
       data[i][0] = column[i];
     }
   }
 
   inline constexpr explicit matrix(Type(row)[Column])
-    requires(Row == 1 && Column > 1)
+    requires(Row == 1 && Column != 1)
   {
     for (decltype(Column) j{0}; j < Column; ++j) {
       data[0][j] = row[j];
     }
   }
 
   inline constexpr matrix(const auto &...elements)
-    requires(Row > 1 && Column == 1 && sizeof...(elements) == Row)
+    requires(Row != 1 && Column == 1 && sizeof...(elements) == Row)
   {
     decltype(Row) i{0};
     ([&] { data[i++][0] = elements; }(), ...);
   }
 
   inline constexpr matrix(const auto &...elements)
-    requires(Row == 1 && Column > 1 && sizeof...(elements) == Column)
+    requires(Row == 1 && Column != 1 && sizeof...(elements) == Column)
   {
     decltype(Column) j{0};
     ([&] { data[0][j++] = elements; }(), ...);
@@ -108,42 +123,43 @@ template <typename Type = double, auto Row = 1, auto Column = 1> struct matrix {
     }
   }
 
-  inline constexpr explicit(false) operator Type() const
+  [[nodiscard]] inline constexpr explicit(false) operator Type() const
     requires(Row == 1 && Column == 1)
   {
     return data[0][0];
   }
 
-  inline constexpr const Type &operator[](auto index) const
-    requires(Row > 1 && Column == 1)
+  [[nodiscard]] inline constexpr const Type &operator[](auto index) const
+    requires(Row != 1 && Column == 1)
   {
     return data[index][0];
   }
 
-  inline constexpr const Type &operator[](auto index) const
+  [[nodiscard]] inline constexpr const Type &operator[](auto index) const
     requires(Row == 1)
   {
     return data[0][index];
   }
 
-  inline constexpr const Type &operator()(auto index) const
-    requires(Row > 1 && Column == 1)
+  [[nodiscard]] inline constexpr const Type &operator()(auto index) const
+    requires(Row != 1 && Column == 1)
   {
     return data[index][0];
   }
 
-  inline constexpr const Type &operator()(auto index) const
+  [[nodiscard]] inline constexpr const Type &operator()(auto index) const
     requires(Row == 1)
   {
     return data[0][index];
   }
 
-  inline constexpr const Type &operator()(auto row, auto column) const {
+  [[nodiscard]] inline constexpr const Type &operator()(auto row,
+                                                        auto column) const {
     return data[row][column];
   }
 
   [[nodiscard]] inline constexpr bool operator==(const matrix &other) const
-    requires(Row > 1 || Column > 1)
+    requires(Row != 1 || Column != 1)
   = default;
 
   [[no_unique_address]] Type data[Row][Column]{};
@@ -166,7 +182,14 @@ template <typename Type, auto Row, auto Column>
 matrix(const Type (&)[Row][Column]) -> matrix<Type, Row, Column>;
 
 template <typename Type, auto Row>
-matrix(const Type (&)[Row]) -> matrix<Type, Row, 1>; // column_vector
+matrix(const Type (&)[Row]) -> matrix<Type, Row, 1>;
+
+template <typename... Types, auto... Columns>
+  requires(std::conjunction_v<std::is_same<first_t<Types...>, Types>...> &&
+           ((Columns == first_v<Columns>)&&... && true))
+matrix(const Types (&...rows)[Columns])
+    -> matrix<std::remove_cvref_t<first_t<Types...>>, sizeof...(Columns),
+              (Columns, ...)>;
 //! @}
 
 //! @name Algebraic Named Values