matrix.hxx

Go to the documentation of this file.

// -*- C++ -*- Header compatibility <matrix.hxx>
 
 
#ifndef CORTEX_MATRIX
#   define CORTEX_MATRIX
 
#include <iterators/normal.hxx>
 
#include <algorithm>
#include <compare>
#include <functional>
#include <initializer_list>
#include <memory>
#include <utility>
#include <vector>
 
namespace cxl
{
    template <typename T, typename Alloc = std::allocator<T>>
    class matrix
    {
    public:
        using value_type                            = T;
        using size_type                             = std::size_t;
        using difference_type                       = std::ptrdiff_t;
 
        using allocator_type                        = Alloc;
        using alloc_traits                          = typename std::allocator_traits<Alloc>;
 
        using reference                             = T&;
        using const_reference                       = const T&;
        using pointer                               = typename alloc_traits::pointer;
        using const_pointer                         = typename alloc_traits::const_pointer;
 
        using iterator                              = cxl::normal_iterator<pointer, matrix>;
        using const_iterator                        = cxl::normal_iterator<const_pointer, matrix>;
        using reverse_iterator                      = std::reverse_iterator<iterator>;
        using const_reverse_iterator                = std::reverse_iterator<const_iterator>;
 
    private:
        size_type m_num_rows;
        size_type m_num_columns;
 
        allocator_type m_allocator;
        pointer m_start;
        pointer m_finish;
 
    public:
 
        constexpr
        matrix() noexcept
            : m_num_rows{ size_type{} }
            , m_num_columns{ size_type{} }
            , m_allocator{ allocator_type{} }
            , m_start{ pointer{} }
            , m_finish{ pointer{} }
        { }
 
        explicit constexpr 
        matrix(const allocator_type& alloc) noexcept
            : m_num_rows{ size_type{} }
            , m_num_columns{ size_type{} }
            , m_allocator{ alloc }
            , m_start{ pointer{} }
            , m_finish{ pointer{} }
        { }
 
        explicit constexpr 
        matrix(size_type num_rows, size_type num_columns, const allocator_type& alloc = allocator_type{})
            : m_num_rows{ num_rows }
            , m_num_columns{ num_columns }
            , m_allocator{ alloc }
            , m_start{ _M_allocate(_M_size_check(num_rows, num_columns)) }
            , m_finish{ m_start + size() }
        {
            if constexpr (std::is_default_constructible_v<value_type>)
                std::ranges::uninitialized_default_construct(*this);
            else
                std::ranges::uninitialized_fill(*this, value_type{});
        }
 
        explicit constexpr 
        matrix(size_type num_rows, size_type num_columns, const_reference fill_value, const allocator_type& alloc = allocator_type())
            : m_num_rows{ num_rows }
            , m_num_columns{ num_columns }
            , m_allocator{ alloc }
            , m_start{ _M_allocate(_M_size_check(num_rows, num_columns)) }
            , m_finish{ m_start + size() }
        { std::ranges::uninitialized_fill(*this, fill_value); }
 
        constexpr
        matrix(const matrix& other)
            : m_num_rows{ other.m_num_rows }
            , m_num_columns{ other.m_num_columns}
            , m_allocator{ other.m_allocator }
            , m_start{ _M_allocate(_M_size_check(m_num_rows, m_num_columns)) }
            , m_finish{ m_start + size() }
        { std::ranges::uninitialized_copy(other, *this); }
 
        explicit constexpr
        matrix(const matrix& other, const allocator_type& alloc)
            : m_num_rows{ other.m_num_rows }
            , m_num_columns{ other.m_num_columns }
            , m_allocator{ alloc }
            , m_start{ _M_allocate(_M_size_check(other.m_num_rows, other.m_num_columns)) }
            , m_finish{ m_start + size() }
        { std::ranges::uninitialized_copy(other, *this); }
 
        constexpr
        matrix(matrix&& other) noexcept
            : m_num_rows{ other.m_num_rows }
            , m_num_columns{ other.m_num_columns }
            , m_allocator{ std::move(other.m_allocator) }
            , m_start{ other.m_start }
            , m_finish{ other.m_finish }
        {
            other.m_start = pointer{};
            other.m_finish = pointer{};
            other.m_allocator = allocator_type{};
            other.m_num_rows = size_type{};
            other.m_num_columns = size_type{};
        }
 
        explicit constexpr 
        matrix(matrix&& other, const allocator_type& alloc) noexcept
            : m_num_rows{ other.m_num_rows }
            , m_num_columns{ other.m_num_columns }
            , m_allocator{ alloc }
            , m_start{ other.m_start }
            , m_finish{ other.m_finish }
        {
            other.m_start = pointer{};
            other.m_finish = pointer{};
            other.m_allocator = allocator_type{};
            other.m_num_rows = size_type{};
            other.m_num_columns = size_type{};
            other.m_size = size_type{};
        }
 
        constexpr 
        matrix(std::initializer_list<std::initializer_list<value_type>> list, [[maybe_unused]] const allocator_type& alloc = allocator_type{})
            : m_num_rows{ list.size() }
            , m_num_columns{ list.begin()->size() }
            , m_allocator{ alloc }
            , m_start{ _M_allocate(_M_size_check(m_num_rows, m_num_columns)) }
            , m_finish{ m_start + size() }
        {
            auto offset{ 0uL };
            for (auto row{ list.begin() }; row != list.end(); ++row)
            {
                if (row->size() != this->m_num_columns)
                    throw std::invalid_argument("The size of the inner std::initializer_list must be same size as the number of columns in the matrix");
 
                std::uninitialized_move_n(row->begin(), this->m_num_columns, m_start + offset);
                offset += this->m_num_columns;
            }
        }
 
        explicit constexpr 
        matrix(const std::tuple<size_type, size_type>& dimensions, [[maybe_unused]] const allocator_type& alloc = allocator_type{})
            : m_num_rows{ std::get<0>(dimensions) }
            , m_num_columns{ std::get<1>(dimensions) }
            , m_allocator{ alloc }
            , m_start{ _M_allocate(_M_size_check(m_num_rows, m_num_columns)) }
            , m_finish{ m_start + size() }
        { 
            if constexpr (std::is_default_constructible_v<value_type>)
                std::ranges::uninitialized_default_construct(*this);
            else
                std::ranges::uninitialized_fill(*this, value_type{});
        }
 
        constexpr auto
        operator= (const matrix& other) 
            -> matrix&
        {
            if (*this != other)
            {
                std::ranges::destroy(*this);
                _M_deallocate(m_start, size());
 
                m_num_rows = other.m_num_rows;
                m_num_columns = other.m_num_columns;
                m_allocator = other.m_allocator;
                m_start = _M_allocate(_M_size_check(m_num_rows, m_num_columns));
                m_finish = m_start + size();
                std::ranges::uninitialized_copy(other, *this);
            }
            return *this;
        }
 
        constexpr auto
        operator= (matrix&& other) noexcept 
            -> matrix&
        {
            if (*this != other)
            {
                std::ranges::destroy(*this);
                _M_deallocate(m_start, size());
 
                m_num_rows = other.m_num_rows;
                m_num_columns = other.m_num_columns;
                m_allocator = std::move(other.m_allocator);
                m_start = other.m_start;
                m_finish = other.m_finish;
 
                other.m_start = pointer{};
                other.m_finish = pointer{};
                other.m_allocator = allocator_type{};
                other.m_num_rows = size_type{};
                other.m_num_columns = size_type{};
            }
            return *this;
        }
 
        constexpr auto
        operator= (std::initializer_list<std::initializer_list<value_type>> list) 
            -> matrix&
        {
            std::ranges::destroy(*this);
            _M_deallocate(m_start, size());
 
            m_allocator = allocator_type{};
            m_num_rows = list.size();
            m_num_columns = list.begin()->size();
            m_start = _M_allocate(_M_size_check(m_num_rows, m_num_columns));
            m_finish = m_start + size();
 
            auto offset{ 0uL };
            for (auto row{ list.begin() }; row != list.end(); ++row)
            {
                if (row->size() != this->m_num_columns)
                    throw std::invalid_argument("The size of the inner std::initializer_list must be same size as the number of columns in the matrix");
 
                std::uninitialized_move_n(row->begin(), this->m_num_columns, m_start + offset);
                offset += this->m_num_columns;
            }
 
            return *this;
        }
 
#if __cplusplus >= 202202L
        constexpr
#else
        ~matrix()
#endif
        {
            if (m_start)
            {
                std::ranges::destroy(*this);
                _M_deallocate(m_start, size());
            }
 
            m_num_rows = size_type{};
            m_num_columns = size_type{};
            m_start = pointer{};
            m_finish = pointer{};
            m_allocator = allocator_type{};
        }
 
        constexpr auto
        assign(std::initializer_list<std::initializer_list<value_type>> list) 
            -> void
        {
            auto new_rows { list.size() };
            auto new_columns { list.begin()->size() };
 
            std::ranges::destroy(*this);
 
            if (new_rows != m_num_rows || new_columns != m_num_columns)
            {
                if (m_start)
                    _M_deallocate(m_start, size());
            
                m_start = _M_allocate(_M_size_check(new_rows, new_columns));
                m_finish = m_start + _M_size_check(new_rows, new_columns);
            }
            
            m_num_rows = new_rows;
            m_num_columns = new_columns;
 
            auto offset{ 0uL };
            for (auto row{ list.begin() }; row != list.end(); ++row)
            {
                if (row->size() != this->m_num_columns)
                    throw std::invalid_argument("The size of the inner std::initializer_list must be same size as the number of columns in the matrix");
 
                std::uninitialized_move_n(row->begin(), this->m_num_columns, m_start + offset);
                offset += this->m_num_columns;
            }
        }
 
        constexpr auto 
        resize(size_type new_rows, size_type new_columns) 
            -> void
        { resize(new_rows, new_columns, value_type{}); }
 
        constexpr auto 
        resize(size_type new_rows, size_type new_columns, const_reference fill_value) 
            -> void
        {
            auto old_size{ size() };
            auto new_size{ _M_size_check(new_rows, new_columns) };
 
            auto new_start{ _M_allocate(new_size) };
            auto new_finish{ new_start + new_size };
 
 
            if (new_size > alloc_traits::max_size(m_allocator))
                throw std::length_error("matrix resize too large");
            else
                if (old_size < new_size)
                {
                    if (auto old_finish_pos_in_new{ new_start + old_size }; m_start)
                    {
                        std::ranges::uninitialized_copy(m_start, m_finish, new_start, old_finish_pos_in_new);
                        std::ranges::uninitialized_fill(old_finish_pos_in_new, new_finish, fill_value);
                    }
                    else
                        std::ranges::uninitialized_fill(new_start, new_finish, fill_value);
                }
                else if (old_size > new_size)
                {
                    if (auto size_diff { old_size - new_size }; m_start)
                        std::ranges::uninitialized_copy(m_start, m_finish - size_diff, new_start, new_finish);
                    else
                        std::ranges::uninitialized_fill(new_start, new_finish, fill_value);
                }
 
            std::ranges::destroy(*this);
            _M_deallocate(m_start, old_size);
    
            m_start = new_start;
            m_finish = new_finish;
 
            m_num_rows = new_rows;
            m_num_columns = new_columns;
        }
 
        [[maybe_unused]] constexpr auto 
        erase(const_iterator position) 
            -> iterator
        {
            auto pos { this->begin() + (position - this->cbegin()) };
            std::ranges::destroy_at(std::addressof(*pos));
            std::ranges::uninitialized_fill(pos, pos + 1, value_type{});
 
            return position;
        }
 
        [[maybe_unused]] constexpr auto
        erase(const_iterator first, const_iterator last) 
            -> iterator
        {
            const auto bgn { this->begin() };
            const auto cbgn { this->cbegin() };
 
            auto fst { bgn + (first - cbgn) };
            auto lst { bgn + (last - cbgn) };
 
            std::ranges::destroy(fst, lst);
            return std::ranges::uninitialized_fill(fst, lst, value_type{});
        }
 
        constexpr auto
        clear() 
            -> void
        {
            if (size())
            {
                erase(begin(), end());
 
                _M_deallocate(m_start, size());
                m_num_rows = size_type{};
                m_num_columns = size_type{};
                m_finish = pointer{};
                m_start = pointer{};
            }
        }
 
        constexpr auto 
        reshape(size_type new_rows, size_type new_columns) 
            -> void
        {
            auto new_size{ _M_size_check(new_rows, new_columns) };
 
            if (new_size != size())
                throw std::length_error("Cannot reshape matrix that has different total size");
            else
                resize(new_rows, new_columns);
        }
 
        void swap(matrix& other) noexcept
        {
            matrix tmp = std::move(other);
            other = std::move(*this);
            *this = std::move(tmp);
        }
 
        constexpr auto 
        get_allocator() const noexcept 
            -> allocator_type
        { return m_allocator; }
 
        constexpr auto
        size() const noexcept
            -> size_type
        { 
            return empty() ? size_type{ 0 } 
                           : m_num_rows * m_num_columns != 0uL 
                           ? m_num_rows * m_num_columns 
                           : std::max(m_num_rows, m_num_columns);
        }
 
        constexpr auto
        num_rows() const noexcept 
            -> size_type
        { return m_num_rows; }
 
        constexpr auto
        num_columns() const noexcept 
            -> size_type
        { return m_num_columns; }
 
        constexpr auto
        max_size() const noexcept 
            -> size_type
        { return alloc_traits::max_size(m_allocator); }
 
        constexpr auto 
        shape() const noexcept 
            -> std::tuple<size_type, size_type>
        { return std::make_tuple(m_num_rows, m_num_columns); }
 
        constexpr auto
        is_square() const noexcept 
            -> bool
        { return m_num_rows == m_num_columns; }
 
        constexpr auto
        empty() const noexcept 
            -> bool
        { return m_start == m_finish; }
 
        constexpr auto
        data() noexcept 
            -> pointer
        { return _M_data_ptr(m_start); }
 
        constexpr auto
        data() const noexcept 
            -> const_pointer 
        { return _M_data_ptr(m_start); }
 
        constexpr auto
        at(size_type row, size_type column) 
            -> reference
        {
            _M_range_check(row, column);
            return *(m_start + _M_index(row, column));
        }
 
        constexpr auto
        at(size_type row, size_type column) const 
            -> const_reference
        {
            _M_range_check(row, column);
            return *(m_start + _M_index(row, column));
        }
 
        constexpr auto
        operator() (size_type row, size_type column) 
            -> reference
        { return at(row, column); }
 
        constexpr auto
        operator() (size_type row, size_type column) const 
            -> const_reference 
        { return at(row, column); }
 
        constexpr auto
        front() noexcept 
            -> reference
        { return *begin(); }
 
        constexpr auto
        front() const noexcept 
            -> const_reference
        { return *begin(); }
 
        constexpr auto
        back() noexcept 
            -> reference
        { return *(end() - 1); }
 
        constexpr auto
        back() const noexcept 
            -> const_reference
        { return *(end() - 1); }
 
        constexpr auto
        begin() noexcept 
            -> iterator
        { return iterator(m_start); }
 
        constexpr auto
        begin() const noexcept 
            -> const_iterator
        { return const_iterator(m_start); }
 
        constexpr auto 
        cbegin() const noexcept 
            -> const_iterator
        { return const_iterator(m_start); }
 
        constexpr auto
        rbegin() noexcept 
            -> reverse_iterator
        { return reverse_iterator(end()); }
 
        constexpr auto
        rbegin() const noexcept 
            -> const_reverse_iterator
        { return const_reverse_iterator(end()); }
 
        constexpr auto
        crbegin() const noexcept 
            -> const_reverse_iterator
        { return const_reverse_iterator(end()); }
 
        constexpr auto
        end() noexcept 
            -> iterator
        { return iterator(m_finish); }
 
        constexpr auto
        end() const noexcept 
            -> const_iterator
        { return const_iterator(m_finish); }
 
        constexpr auto
        cend() const noexcept 
            -> const_iterator
        { return const_iterator(m_finish); }
 
        constexpr auto
        rend() noexcept 
            -> reverse_iterator
        { return reverse_iterator(begin()); }
 
        constexpr auto
        rend() const noexcept 
            -> const_reverse_iterator
        { return const_reverse_iterator(begin()); }
 
        constexpr auto 
        crend() const noexcept 
            -> const_reverse_iterator
        { return const_reverse_iterator(begin()); }
 
        // constexpr auto 
        // transpose()
        // {
        //     matrix<value_type> result(this->num_columns(), this->num_rows());
 
        //     if (empty())
        //         return result;
 
        //     std::ranges::copy(*this, result.column_begin());
 
        //     return result;
        // }
 
        template<std::copy_constructible F>
        constexpr auto
        map(F func) const 
            -> matrix<std::invoke_result_t<F, value_type>>
        {
            if (empty())
                return matrix<std::invoke_result_t<F, value_type>>{};
            else
            {
                matrix<std::invoke_result_t<F, value_type>> result(this->num_rows(), this->num_columns());
                std::ranges::transform(*this, result.begin(), func);
                return result;
            }
        }
 
        template<std::ranges::input_range Rng, std::copy_constructible F>
        constexpr auto
        map(Rng&& rng, F func) const 
            -> matrix<std::invoke_result_t<F, value_type, typename std::remove_cvref_t<decltype(*std::ranges::begin(rng))>>>
        {
            using range_elem_t = typename std::remove_cvref_t<decltype(*std::ranges::begin(rng))>;
 
            if (empty())
                return matrix<std::invoke_result_t<F, value_type, range_elem_t>>{};
            else
            {
                matrix<std::invoke_result_t<F, value_type, range_elem_t>> result(this->num_rows(), this->num_columns());
                std::ranges::transform(*this, rng, result.begin(), func);
                return result;
            }
        }
 
        template<std::input_iterator It, std::sentinel_for<It> Sn, std::copy_constructible Fn>
        constexpr auto
        map(It first, Sn last, Fn func) const 
            -> matrix<std::invoke_result_t<Fn, value_type, typename std::remove_cvref_t<typename std::iterator_traits<It>::value_type>>>
        {
            using iterator_elem_t = typename std::remove_cvref_t<typename std::iterator_traits<It>::value_type>;
 
            if (empty())
                return matrix<std::invoke_result_t<Fn, value_type, iterator_elem_t>>{};
            else
            {
                matrix<std::invoke_result_t<Fn, value_type, iterator_elem_t>> result(this->num_rows(), this->num_columns());
                std::ranges::transform(this->begin(), this->end(), first, last, result.begin(), func);
                return result;
            }
        }
 
        // constexpr auto vflip() const
        // {
        //     if (empty())
        //         return matrix<value_type>{};
        //     else
        //     {
        //         matrix<value_type> result(this->num_rows(), this->num_columns());
 
        //         for (auto cidx { 0u }; cidx < this->num_columns(); ++cidx)
        //             std::ranges::copy(this->column_begin(cidx), this->column_end(cidx), result.column_rbegin(cidx));
 
        //         return result;
        //     }
        // }
 
        // constexpr auto hflip() const
        // {
        //     if (empty())
        //         return matrix<value_type>{};
        //     else
        //     {
        //         matrix<value_type> result(this->num_rows(), this->num_columns());
        //             for (auto ridx { 0u }; ridx < this->num_rows(); ++ridx)
        //                 std::ranges::copy(this->row_begin(ridx), this->row_end(ridx), result.row_rbegin(ridx));
 
        //         return result;
        //     }
        // }
 
        // constexpr auto rrotate() const
        // {
        //     if (empty())
        //         return matrix<value_type>{};
        //     else
        //     {
        //         matrix<value_type> result(this->num_columns(), this->num_rows());
 
        //         for (auto cidx { 0u }; cidx < this->num_columns(); ++cidx)
        //             std::ranges::copy(this->column_begin(cidx), this->column_end(cidx), result.row_rbegin(cidx));
 
        //         return result;
        //     }
        // }
 
        // constexpr auto lrotate() const
        // {
        //     if (empty())
        //         return matrix<value_type>{};
        //     else
        //     {
        //         matrix<value_type> result(this->num_columns(), this->num_rows());
 
        //         for (auto ridx { 0u }; ridx < this->num_rows(); ++ridx)
        //             std::ranges::copy(this->row_begin(ridx), this->row_end(ridx), result.column_rbegin(ridx));
 
        //         return result;
        //     }
        // }
 
    private:
        constexpr auto
        _M_allocate(size_type n) 
            -> pointer
        { return n != 0 ? alloc_traits::allocate(m_allocator, n) : pointer{}; }
 
        constexpr auto
        _M_deallocate(pointer ptr, [[maybe_unused]] size_type n) 
            -> void
        {
            if (ptr)
                alloc_traits::deallocate(m_allocator, ptr, n);
        }
 
        constexpr auto
        _M_range_check(size_type row, size_type column) const 
            -> void
        {
            if (row >= m_num_rows || column >= m_num_columns)
                throw std::out_of_range("matrix::_M_range_check - index out of range.");
        }
 
        constexpr auto
        _M_size_check(size_type row, size_type column) const
            -> size_type
        { 
            if (row == 0uL)
                throw std::invalid_argument{ "BoxView::_M_size_check - row size cannot be zero" };
            else if (column == 0uL)
                throw std::invalid_argument{ "BoxView::_M_size_check - column size cannot be zero" };
            else
                return row * column;
        }
 
        constexpr auto
        _M_index(size_type row, size_type column) const noexcept 
            -> size_type
        { return row * m_num_columns + column; }
 
        template <typename U>
        constexpr auto
        _M_data_ptr(U* ptr) const noexcept 
            -> U*
        { return ptr; }
 
#if __cplusplus >= 201103L
        template <typename Ptr>
        constexpr auto
        _M_data_ptr(Ptr ptr) const 
            -> typename std::pointer_traits<Ptr>::element_type*
        { return empty() ? nullptr : std::to_address(*ptr); }
#else
 
        template <typename U>
        constexpr auto
        _M_data_ptr(U* ptr) noexcept 
            -> U*
        { return ptr; }
#endif  //< __cplusplus >= 201103L
    
    };  //< class matrix
 
    template <typename ElemL, typename ElemR>
        requires requires(ElemL lhsE, ElemR rhsE) {
            { lhsE == rhsE } -> std::convertible_to<bool>;
        }
    constexpr inline auto
    operator== (const matrix<ElemL>& lhs, const matrix<ElemR>& rhs) noexcept(
        noexcept(std::declval<ElemL>() == std::declval<ElemR>())
           && noexcept(std::ranges::equal(lhs, rhs))) -> bool
    {
        if (lhs.shape() != rhs.shape())
            return false;
        return std::ranges::equal(lhs, rhs);
    }
 
    template <typename ElemL, typename ElemR>
    constexpr inline auto
    operator<=> (const matrix<ElemL>& lhs, const matrix<ElemR>& rhs)
    { return std::lexicographical_compare_three_way(lhs.begin(), lhs.end(), rhs.begin(), rhs.end(), std::compare_three_way{}); }
 
    template<typename E, std::copy_constructible F>
    constexpr auto
    operator|| (const matrix<E>& bx, F f) noexcept
        -> matrix<std::invoke_result_t<F, E>>
    { return bx.map(f); }
 
}  //< namespace cxl
 
namespace std
{
    template <typename T>
    constexpr inline auto
    swap(cxl::matrix<T>& x, cxl::matrix<T>& y) 
        noexcept( noexcept(x.swap(y)) ) -> void
    { x.swap(y); }
}
 
#endif  //< CORTEX_MATRIX_H