Matrix.hpp

#pragma once
 
#include <stratax/core/containers/Buffer.hpp>
#include <stratax/core/Concepts.hpp>
#include <stratax/core/containers/Shape.hpp>
#include <stratax/core/Exceptions.hpp>
#include <stratax/core/containers/Strides.hpp>
#include <stratax/core/validation/Validation.hpp>
 
#include <initializer_list>
#include <cstddef>
#include <iterator>
#include <utility>
 
namespace stratax::container {

template<typename T>
requires Numeric<T>
class Matrix
{
private:
    core::Shape shape_;
    core::Strides strides_;
    core::Buffer<T> buffer_;
 
public:
    using value_type = T;

    using iterator = typename core::Buffer<T>::iterator;

    using const_iterator = typename core::Buffer<T>::const_iterator;

    using reverse_iterator = typename core::Buffer<T>::reverse_iterator;

    using const_reverse_iterator = typename core::Buffer<T>::const_reverse_iterator;

    template<typename U>
    using rebind = Matrix<U>;

    Matrix(): Matrix(0, 0) {}

    Matrix(std::size_t rows, std::size_t cols)
        : shape_({rows, cols}, core::Shape::allow_zero),
          strides_(shape_),
          buffer_(core::validation::checked_multiply(rows, cols, "Matrix size overflow"))
    {
    }

    explicit Matrix(const core::Shape& shape)
        : shape_(core::validation::require_rank(shape, 2, "Shape must be rank 2")),
          strides_(shape_),
          buffer_(core::validation::checked_multiply(
              shape_(0),
              shape_(1),
              "Matrix size overflow"))
    {
    }

    Matrix(std::size_t rows, std::size_t cols, const T& value)
        : shape_({rows, cols}, core::Shape::allow_zero),
          strides_(shape_),
          buffer_(core::validation::checked_multiply(rows, cols, "Matrix size overflow"), value)
    {
    }

    Matrix(std::initializer_list<std::initializer_list<T>> list)
    {
        std::size_t rows = list.size();
        std::size_t cols = (rows == 0) ? 0 : list.begin()->size();
 
        // Ensure all rows have the same length
        for (const auto& row : list)
        {
            if (row.size() != cols)
            {
                throw Exceptions::ShapeError("Matrix initializer rows must all have the same number of columns.");
            }
        }
 
        shape_ = stratax::core::Shape({rows, cols}, stratax::core::Shape::allow_zero);
        strides_ = stratax::core::Strides(shape_);
        buffer_ = stratax::core::Buffer<T>(
            core::validation::checked_multiply(rows, cols, "Matrix size overflow"));
 
        std::size_t index = 0;
 
        for (const auto& row : list)
        {
            for (const auto& value : row)
            {
                buffer_[index++] = value;
            }
        }
    }

    Matrix(const Matrix&) = default;

    Matrix(Matrix&&) noexcept = default;

    Matrix& operator=(const Matrix&) = default;

    Matrix& operator=(Matrix&&) noexcept = default;

    ~Matrix() = default;

    [[nodiscard]] std::size_t size() const noexcept
    {
        return shape_.elements();
    }

    [[nodiscard]] bool empty() const noexcept
    {
        return buffer_.empty();
    }

    [[nodiscard]] std::size_t rows() const noexcept
    {
        return shape_(0);
    }

    [[nodiscard]] std::size_t cols() const noexcept
    {
        return shape_(1);
    }

    const stratax::core::Shape& shape() const noexcept
    {
        return shape_;
    }

    const stratax::core::Strides& strides() const noexcept
    {
        return strides_;
    }

    [[nodiscard]] std::size_t rank() const noexcept
    {
        return shape_.rank();
    }

    T& operator()(std::size_t row, std::size_t col)
    {
        core::validation::require_index(row, rows(), "Row index out of bounds.");
        core::validation::require_index(col, cols(), "Column index out of bounds.");
        return buffer_[row * cols() + col];
    }

    const T& operator()(std::size_t row, std::size_t col) const
    {
        core::validation::require_index(row, rows(), "Row index out of bounds.");
        core::validation::require_index(col, cols(), "Column index out of bounds.");
        return buffer_[row * cols() + col];
    }

    T& operator[](std::size_t index) noexcept
    {
        return buffer_[index];
    }

    const T& operator[](std::size_t index) const noexcept
    {
        return buffer_[index];
    }

    T& at(std::ptrdiff_t row, std::ptrdiff_t col)
    {
        const std::size_t normalized_row =
            core::validation::normalize_index(row, rows(), "Row index out of bounds.");
        const std::size_t normalized_col =
            core::validation::normalize_index(col, cols(), "Column index out of bounds.");
        return (*this)(normalized_row, normalized_col);
    }

    const T& at(std::ptrdiff_t row, std::ptrdiff_t col) const
    {
        const std::size_t normalized_row =
            core::validation::normalize_index(row, rows(), "Row index out of bounds.");
        const std::size_t normalized_col =
            core::validation::normalize_index(col, cols(), "Column index out of bounds.");
        return (*this)(normalized_row, normalized_col);
    }

    T& front()
    {
        if (empty())
        {
            throw Exceptions::IndexError("Matrix front cannot be accessed when the matrix is empty.");
        }
 
        return buffer_.front();
    }

    const T& front() const
    {
        if (empty())
        {
            throw Exceptions::IndexError("Matrix front cannot be accessed when the matrix is empty.");
        }
 
        return buffer_.front();
    }

    T& back()
    {
        if (empty())
        {
            throw Exceptions::IndexError("Matrix back cannot be accessed when the matrix is empty.");
        }
 
        return buffer_.back();
    }

    const T& back() const
    {
        if (empty())
        {
            throw Exceptions::IndexError("Matrix back cannot be accessed when the matrix is empty.");
        }
 
        return buffer_.back();
    }

    [[nodiscard]] T* data() noexcept
    {
        return buffer_.data();
    }

    [[nodiscard]] const T* data() const noexcept
    {
        return buffer_.data();
    }

    [[nodiscard]] iterator begin() noexcept
    {
        return buffer_.begin();
    }

    [[nodiscard]] const_iterator begin() const noexcept
    {
        return buffer_.begin();
    }

    [[nodiscard]] const_iterator cbegin() const noexcept
    {
        return buffer_.cbegin();
    }

    [[nodiscard]] iterator end() noexcept
    {
        return buffer_.end();
    }

    [[nodiscard]] const_iterator end() const noexcept
    {
        return buffer_.end();
    }

    [[nodiscard]] const_iterator cend() const noexcept
    {
        return buffer_.cend();
    }

    [[nodiscard]] reverse_iterator rbegin() noexcept
    {
        return buffer_.rbegin();
    }

    [[nodiscard]] const_reverse_iterator rbegin() const noexcept
    {
        return buffer_.rbegin();
    }

    [[nodiscard]] const_reverse_iterator crbegin() const noexcept
    {
        return buffer_.crbegin();
    }

    [[nodiscard]] reverse_iterator rend() noexcept
    {
        return buffer_.rend();
    }

    [[nodiscard]] const_reverse_iterator rend() const noexcept
    {
        return buffer_.rend();
    }

    [[nodiscard]] const_reverse_iterator crend() const noexcept
    {
        return buffer_.crend();
    }

    void fill(const T& value)
    {
        buffer_.fill(value);
    }

    void swap(Matrix& other) noexcept
    {
        using std::swap;
 
        swap(shape_, other.shape_);
        swap(strides_, other.strides_);
        swap(buffer_, other.buffer_);
    }
};
 
}