Matrix.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <cstddef>
#include <initializer_list>
 
#include <stratax/core/dtypes/Concepts.hpp>
#include <stratax/core/ArrayBase.hpp>
#include <stratax/core/Shape.hpp>
#include <stratax/exceptions/Exceptions.hpp>
 
namespace stratax::container {
 
template<typename T>
requires DType<T>
class Matrix : public core::ArrayBase<T>
{
public:
    using value_type = typename core::ArrayBase<T>::value_type;
    using size_type = typename core::ArrayBase<T>::size_type;
    using difference_type = typename core::ArrayBase<T>::difference_type;
    using reference = typename core::ArrayBase<T>::reference;
    using const_reference = typename core::ArrayBase<T>::const_reference;
    using pointer = typename core::ArrayBase<T>::pointer;
    using const_pointer = typename core::ArrayBase<T>::const_pointer;
    using iterator = typename core::ArrayBase<T>::iterator;
    using const_iterator = typename core::ArrayBase<T>::const_iterator;
    using reverse_iterator = typename core::ArrayBase<T>::reverse_iterator;
    using const_reverse_iterator = typename core::ArrayBase<T>::const_reverse_iterator;
 
private:
    static core::Shape initializer_shape(
        std::initializer_list<std::initializer_list<value_type>> list)
    {
        const size_type rows = list.size();
        const size_type cols = rows == 0 ? 0 : list.begin()->size();
 
        for (const auto& row : list)
        {
            if (row.size() != cols)
            {
                throw Exceptions::ShapeError(
                    "Matrix initializer rows must have equal lengths.");
            }
        }
 
        return core::Shape{rows, cols};
    }
 
protected:
    using core::ArrayBase<T>::normalized_flat_offset;
 
public:
    using core::ArrayBase<T>::at;
 
    Matrix() : Matrix(0, 0) {}
 
    Matrix(const Matrix&) = default;
    Matrix& operator=(const Matrix&) = default;
 
    Matrix(Matrix&& other) : Matrix() { swap(other); }
 
    Matrix& operator=(Matrix&& other)
    {
        if (this != &other)
        {
            Matrix moved(std::move(other));
            swap(moved);
        }
        return *this;
    }
 
    Matrix(size_type rows, size_type cols)
        : core::ArrayBase<T>(core::Shape{rows, cols})
    {}
 
    Matrix(size_type rows, size_type cols, const_reference value)
        : core::ArrayBase<T>(core::Shape{rows, cols}, value)
    {}
 
    explicit Matrix(const core::Shape& shape)
        : core::ArrayBase<T>(shape)
    {
        if (shape.rank() != 2)
        {
            throw Exceptions::RankError("Matrix requires a rank-2 shape.");
        }
    }
 
    Matrix(std::initializer_list<std::initializer_list<value_type>> list)
        : core::ArrayBase<T>(initializer_shape(list))
    {
        size_type index = 0;
 
        for (const auto& row : list)
        {
            for (const auto& value : row)
            {
                (*this)[index++] = value;
            }
        }
    }
 
    [[nodiscard]] size_type rows() const noexcept {return this->shape()[0];}
    [[nodiscard]] size_type cols() const noexcept {return this->shape()[1];}
 
    reference operator()(size_type row, size_type col) {return (*this)[row * cols() + col];}
    const_reference operator()(size_type row, size_type col) const {return (*this)[row * cols() + col];}
 
    reference at(difference_type row, difference_type col) {return (*this)[normalized_flat_offset(std::array<difference_type, 2>{row, col})];}
    const_reference at(difference_type row, difference_type col) const {return (*this)[normalized_flat_offset(std::array<difference_type, 2>{row, col})];}
 
    void swap(Matrix& other) noexcept {core::ArrayBase<T>::swap(other);}
    friend void swap(Matrix& lhs, Matrix& rhs) noexcept {lhs.swap(rhs);}
};
 
} // namespace stratax::container