Class Matrix

vectorization/src/main/cpp/matrix.h:30–136

template <size_t Rows, size_t Columns, typename T = float>
class Matrix {
 public:
  Matrix() = default;
  Matrix(T (&&cells)[Rows][Columns]) {
    for (size_t row = 0; row < Rows; row++) {
      for (size_t column = 0; column < Columns; column++) {
        (*this)[row, column] = cells[row][column];
      }
    }
  }

  // Convenience constructor for vectors so callers don't need to use
  // `{{x}, {y}, {z}}`.
  Matrix(const std::array<T, Rows> cells)
    requires(Columns == 1)
      : cells_(cells) {}

  [[nodiscard, clang::always_inline]] constexpr const T* _Nonnull data() const {
    return cells_.data();
  }

  [[nodiscard, clang::always_inline]] constexpr T* _Nonnull data() {
    return cells_.data();
  }

  [[nodiscard, clang::always_inline]] constexpr T& get(size_t row,
                                                       size_t column) {
    return cells_[column * Rows + row];
  }

  [[nodiscard, clang::always_inline]] constexpr const T& get(
      size_t row, size_t column) const {
    return cells_[column * Rows + row];
  }

  [[nodiscard, clang::always_inline]] constexpr T& operator[](size_t row,
                                                              size_t column) {
    return get(row, column);
  }

  [[nodiscard, clang::always_inline]] constexpr const T& operator[](
      size_t row, size_t column) const {
    return get(row, column);
  }

  [[nodiscard, clang::always_inline]] constexpr const std::span<const T> column(
      size_t column) const {
    return std::span{&get(0, column), Rows};
  }

  [[nodiscard, clang::always_inline]] constexpr std::span<T> column(
      size_t column) {
    return std::span{&get(0, column), Rows};
  }

  bool operator==(const Matrix<Rows, Columns, T>& rhs) const {
    return cells_ == rhs.cells_;
  }