multiarray.h

Go to the documentation of this file.

 
/*
Copyright (c) 2026 MrXie1109
 
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
 
#pragma once
#include <algorithm>
#include <array>
#include <cstddef>
#include <cstring>
#include <initializer_list>
#include <iostream>
#include <memory>
#include <stdexcept>
#include <type_traits>
 
#include "../core/csexc.h"
#include "../text/repr.h"
 
namespace console {
#ifdef CONSOLE_MULTIARRAY_V1
    inline
#endif
        namespace _V1 {
        template <class T, size_t... Dims>
        class MultiArray;

        template <class T, size_t D>
        class MultiArray<T, D> : public std::array<T, D> {
            using base_type = std::array<T, D>;
 
        public:
            using value_type      = T;
            using reference       = T &;
            using const_reference = const T &;

            MultiArray() = default;

            explicit MultiArray(const T &value) { fill(value); }

            MultiArray(const base_type &other) : base_type(other) {}

            MultiArray(std::initializer_list<T> init) {
                std::copy(init.begin(), init.end(), this->begin());
            }

            static constexpr size_t rank() { return 1; }

            static constexpr size_t fsize() { return D; }

            void fill(const T &value) {
                for (auto &item : *this) item = value;
            }

            template <class F>
            void for_each(F &&visit) {
                for (auto &item : *this) visit(item);
            }

            template <class F>
            void for_each(F &&visit) const {
                for (const auto &item : *this) visit(item);
            }

            reference operator()(size_t i) {
                if (i >= D)
                    throw MultiArrayError("index " + std::to_string(i)
                                          + " out of range [0, "
                                          + std::to_string(D) + ')');
                return (*this)[i];
            }

            const_reference operator()(size_t i) const {
                if (i >= D)
                    throw MultiArrayError("index " + std::to_string(i)
                                          + " out of range [0, "
                                          + std::to_string(D) + ')');
                return (*this)[i];
            }

            friend std::ostream &
            operator<<(std::ostream &os, const MultiArray &ma) {
                if (ma.begin() == ma.end()) return os << "[]";
                auto it = ma.begin();
                os << '[';
                repr(*it, os);
                while (++it != ma.end()) {
                    os << ", ";
                    repr(*it, os);
                }
                return os << ']';
            }

            T *fbegin() { return this->data(); }

            const T *fbegin() const { return this->data(); }

            T *fend() { return this->data() + fsize(); }

            const T *fend() const { return this->data() + fsize(); }

            MultiArray &flatten() { return *this; }

            const MultiArray &flatten() const { return *this; }

            static constexpr std::array<size_t, 1> dims() { return {D}; }

            template <size_t... Dims>
            MultiArray<T, Dims...> &reshape() {
                static_assert(MultiArray<T, Dims...>::fsize() == fsize(),
                    "reshape: total element count must match");
                return *reinterpret_cast<MultiArray<T, Dims...> *>(this);
            }

            template <size_t... Dims>
            const MultiArray<T, Dims...> &reshape() const {
                static_assert(MultiArray<T, Dims...>::fsize() == fsize(),
                    "reshape: total element count must match");
                return *reinterpret_cast<const MultiArray<T, Dims...> *>(this);
            }
        };

        template <class T, size_t First, size_t... Rest>
        class MultiArray<T, First, Rest...>
            : public std::array<MultiArray<T, Rest...>, First> {
            using base_type = std::array<MultiArray<T, Rest...>, First>;
 
        public:
            using value_type      = MultiArray<T, Rest...>;
            using reference       = MultiArray<T, Rest...> &;
            using const_reference = const MultiArray<T, Rest...> &;

            MultiArray() = default;

            explicit MultiArray(const T &value) { fill(value); }

            MultiArray(const base_type &other) : base_type(other) {}

            MultiArray(std::initializer_list<MultiArray<T, Rest...>> init) {
                std::copy(init.begin(), init.end(), this->begin());
            }

            static constexpr size_t rank() { return 1 + sizeof...(Rest); }

            static constexpr size_t fsize() {
                return First * MultiArray<T, Rest...>::fsize();
            }

            void fill(const T &value) {
                for (auto &sub : *this) sub.fill(value);
            }

            template <class F>
            void for_each(F &&visit) {
                for (auto &sub : *this) sub.for_each(visit);
            }

            template <class F>
            void for_each(F &&visit) const {
                for (const auto &sub : *this) sub.for_each(visit);
            }

            reference operator()(size_t idx) {
                if (idx >= First)
                    throw MultiArrayError("index " + std::to_string(idx)
                                          + " out of range [0, "
                                          + std::to_string(First) + ')');
                return base_type::operator[](idx);
            }

            const_reference operator()(size_t idx) const {
                if (idx >= First)
                    throw MultiArrayError("index " + std::to_string(idx)
                                          + " out of range [0, "
                                          + std::to_string(First) + ')');
                return base_type::operator[](idx);
            }

            template <class... Indices>
            auto operator()(size_t idx, Indices... rest)
                -> decltype(base_type::operator[](idx)(rest...)) {
                static_assert(
                    sizeof...(Indices) < rank(), "Too Many Arguments!");
                if (idx >= First)
                    throw MultiArrayError("index " + std::to_string(idx)
                                          + " out of range [0, "
                                          + std::to_string(First) + ')');
                return base_type::operator[](idx)(rest...);
            }

            template <class... Indices>
            auto operator()(size_t idx, Indices... rest) const
                -> decltype(base_type::operator[](idx)(rest...)) {
                static_assert(
                    sizeof...(Indices) < rank(), "Too Many Arguments!");
                if (idx >= First)
                    throw MultiArrayError("index " + std::to_string(idx)
                                          + " out of range [0, "
                                          + std::to_string(First) + ')');
                return base_type::operator[](idx)(rest...);
            }

            friend std::ostream &
            operator<<(std::ostream &os, const MultiArray &ma) {
                if (ma.begin() == ma.end()) return os << "[]";
                auto it = ma.begin();
                os << '[' << *it;
                while (++it != ma.end()) {
                    os << ", " << *it;
                }
                return os << ']';
            }

            T *fbegin() { return this->data()->fbegin(); }

            const T *fbegin() const { return this->data()->fbegin(); }

            T *fend() { return this->fbegin() + this->fsize(); }

            const T *fend() const { return this->fbegin() + this->fsize(); }

            MultiArray<T, fsize()> &flatten() {
                return reinterpret_cast<MultiArray<T, fsize()> &>(*this);
            }

            const MultiArray<T, fsize()> &flatten() const {
 
                return reinterpret_cast<const MultiArray<T, fsize()> &>(*this);
            }

            static constexpr std::array<size_t, rank()> dims() {
                return {First, Rest...};
            }

            template <size_t... Dims>
            MultiArray<T, Dims...> &reshape() {
                static_assert(MultiArray<T, Dims...>::fsize() == fsize(),
                    "reshape: total element count must match");
                return *reinterpret_cast<MultiArray<T, Dims...> *>(this);
            }

            template <size_t... Dims>
            const MultiArray<T, Dims...> &reshape() const {
                static_assert(MultiArray<T, Dims...>::fsize() == fsize(),
                    "reshape: total element count must match");
                return *reinterpret_cast<const MultiArray<T, Dims...> *>(this);
            }
        };
    }
 
#ifndef CONSOLE_MULTIARRAY_V1
    inline
#endif
        namespace _V2 {

        template <class T>
        struct _multi_array_base {
            T   *data_;     
            bool is_views_; 

            _multi_array_base(T *data, bool is_views) :
                data_(data), is_views_(is_views) {}
        };

        template <class T, size_t... Dims>
        class MultiArray;

        template <class T, size_t D>
        class MultiArray<T, D> : private _multi_array_base<T> {
        public:
            using _multi_array_base<T>::data_;     
            using _multi_array_base<T>::is_views_; 
 
            static constexpr size_t SIZE = D; 

            MultiArray(T *data, bool is_views) :
                _multi_array_base<T>{data, is_views} {}

            MultiArray(const T *data, bool is_views) :
                _multi_array_base<T>{const_cast<T *>(data), is_views} {}
 
            template <class U, size_t... Dims>
            friend class MultiArray;
 
        public:
            using value_type       = T;
            using size_type        = size_t;
            using difference_type  = ptrdiff_t;
            using pointer          = value_type *;
            using const_pointer    = const value_type *;
            using reference        = value_type &;
            using const_reference  = const value_type &;
            using iterator         = value_type *;
            using const_iterator   = const value_type *;
            using reverse_iterator = std::reverse_iterator<iterator>;
            using const_reverse_iterator
                = std::reverse_iterator<const_iterator>;

            MultiArray() : _multi_array_base<T>{new T[SIZE], false} {}

             */
            MultiArray(const T &value) :
                _multi_array_base<T>{new T[SIZE], false} {
                std::fill(data_, data_ + SIZE, value);
            }

             */
            MultiArray(std::initializer_list<T> init) :
                _multi_array_base<T>{new T[SIZE], false} {
                std::copy(init.begin(), init.end(), data_);
            }

             */
            MultiArray(const MultiArray &other) :
                _multi_array_base<T>{new T[SIZE], false} {
                std::copy(other.data_, other.data_ + SIZE, data_);
            }

             */
            MultiArray(MultiArray &&other) noexcept :
                _multi_array_base<T>{other.data_, other.is_views_} {
                other.is_views_ = true;
            }

             */
            MultiArray &operator=(const MultiArray &other) {
                if (this != &other) {
                    if (!is_views_) delete[] data_;
                    data_ = new T[SIZE];
                    std::copy(other.data_, other.data_ + SIZE, data_);
                }
                return *this;
            }

             */
            MultiArray &operator=(MultiArray &&other) noexcept {
                if (this != &other) {
                    if (!is_views_) delete[] data_;
                    data_       = other.data_;
                    is_views_   = other.is_views_;
                    other.data_ = nullptr;
                }
                return *this;
            }

            MultiArray clone() const { return MultiArray(*this); }

            /// @brief 析构，拥有者释放堆内存，视图不释放。
            ~MultiArray() {
                if (!is_views_) delete[] data_;
            }

            /// @brief 迭代器 begin，返回指向首元素的迭代器。
            iterator begin() { //
                return iterator(data_);
            }
            /// @brief 迭代器 end，返回指向尾元素的迭代器。
            iterator end() { //
                return iterator(data_ + SIZE);
            }
            /// @brief const迭代器 begin，返回指向首元素的 const 迭代器。
            const_iterator begin() const { //
                return const_iterator(data_);
            }
            /// @brief const迭代器 end，返回指向尾元素的 const 迭代器。
            const_iterator end() const { //
                return const_iterator(data_ + SIZE);
            }
            /// @brief 反向迭代器 rbegin，返回指向尾元素的反向迭代器。
            reverse_iterator rbegin() { //
                return reverse_iterator(data_ + SIZE);
            }
            /// @brief 反向迭代器 rend，返回指向首元素的反向迭代器。
            reverse_iterator rend() { //
                return reverse_iterator(data_);
            }
            /// @brief const 反向迭代器 rbegin，返回指向尾元素的 const 反向迭代器。
            const_reverse_iterator rbegin() const {
                return const_reverse_iterator(data_ + SIZE);
            }
            /// @brief const 反向迭代器 rend，返回指向首元素的 const 反向迭代器。
            const_reverse_iterator rend() const {
                return const_reverse_iterator(data_);
            }
            /// @brief const 迭代器 cbegin，返回指向首元素的 const 迭代器。
            const_iterator cbegin() const { //
                return const_iterator(data_);
            }
            /// @brief const 迭代器 cend，返回指向尾元素的 const 迭代器。
            const_iterator cend() const { //
                return const_iterator(data_ + SIZE);
            }
            /// @brief const 反向迭代器 crbegin，返回指向尾元素的 const 反向迭代器。
            const_reverse_iterator crbegin() const {
                return const_reverse_iterator(data_ + SIZE);
            }
            /// @brief const 反向迭代器 crend，返回指向首元素的 const 反向迭代器。
            const_reverse_iterator crend() const {
                return const_reverse_iterator(data_);
            }

            T *fbegin() { return data_; }
            const T *fbegin() const { return data_; }
            T *fend() { return data_ + SIZE; }
            const T *fend() const { return data_ + SIZE; }

            static constexpr size_t rank() { return 1; }
            static constexpr std::array<size_t, rank()> dims() { return {D}; }
            static constexpr size_t fsize() { return SIZE; }
            static constexpr bool fempty() { return SIZE == 0; }
            static constexpr size_t fmax_size() { return SIZE; }

            MultiArray<T, SIZE> &flatten() { return *this; }

            const MultiArray<T, SIZE> &flatten() const { return *this; }

            /// @brief 下标运算符，返回指向 index 位置的引用。
            reference operator[](size_t index) { //
                return data_[index];
            }
            /// @brief 下标运算符，返回指向 index 位置的 const 引用。
            const_reference operator[](size_t index) const {
                return data_[index];
            }

             */
            reference at(size_t index) {
                if (index >= D)
                    throw MultiArrayError("index " + std::to_string(index)
                                          + " out of range [0, "
                                          + std::to_string(D) + ')');
                return data_[index];
            }
             */
            const_reference at(size_t index) const {
                if (index >= D)
                    throw MultiArrayError("index " + std::to_string(index)
                                          + " out of range [0, "
                                          + std::to_string(D) + ')');
                return data_[index];
            }

            reference operator()(size_t index) { return at(index); }
            const_reference operator()(size_t index) const { return at(index); }

            reference front() { return operator[](0); }
            const_reference front() const { return operator[](0); }
            reference back() { return operator[](D - 1); }
            const_reference back() const { return operator[](D - 1); }

            static size_t size() { return D; }
            static bool empty() { return D == 0; }
            static size_t max_size() { return D; }

            template <class CharT, class Traits>
            friend std::basic_ostream<CharT, Traits> &operator<<(
                std::basic_ostream<CharT, Traits> &os, const MultiArray &ma) {
                if (ma.begin() == ma.end()) return os << "[]";
                auto it = ma.begin();
                os << '[';
                repr(*it, os);
                while (++it != ma.end()) {
                    os << ", ";
                    repr(*it, os);
                }
                return os << ']';
            }

            void fill(const T &value) { std::fill(data_, data_ + SIZE, value); }

            template <class F>
            void for_each(F f) {
                std::for_each(data_, data_ + SIZE, f);
            }

            template <class F>
            void for_each(F f) const {
                std::for_each(data_, data_ + SIZE, f);
            }

             */
            void swap(MultiArray &other) noexcept {
                std::swap(data_, other.data_);
                std::swap(is_views_, other.is_views_);
            }

             */
            friend void swap(MultiArray &a, MultiArray &b) noexcept {
                a.swap(b);
            }

            template <size_t... Dims>
            MultiArray<T, Dims...> &reshape() {
                static_assert(MultiArray<T, Dims...>::fsize() == fsize(),
                    "reshape: total element count must match");
                return *reinterpret_cast<MultiArray<T, Dims...> *>(this);
            }

            template <size_t... Dims>
            const MultiArray<T, Dims...> &reshape() const {
                static_assert(MultiArray<T, Dims...>::fsize() == fsize(),
                    "reshape: total element count must match");
                return *reinterpret_cast<const MultiArray<T, Dims...> *>(this);
            }
        };

        template <class T, size_t First, size_t... Rest>
        class MultiArray<T, First, Rest...> : private _multi_array_base<T> {
            using _multi_array_base<T>::data_;     
            using _multi_array_base<T>::is_views_; 

            template <size_t... Is>
            struct prod;
 
            template <size_t I>
            struct prod<I> {
                static constexpr size_t value = I;
            };
 
            template <size_t I, size_t... Is>
            struct prod<I, Is...> {
                static constexpr size_t value = I * prod<Is...>::value;
            };
 
            static constexpr size_t SIZE = prod<First, Rest...>::value;

            MultiArray(T *data, bool is_views) :
                _multi_array_base<T>{data, is_views} {}

            MultiArray(const T *data, bool is_views) :
                _multi_array_base<T>{const_cast<T *>(data), is_views} {}
 
            template <class U, size_t... Dims>
            friend class MultiArray;
 
            friend class iterator;
            friend class const_iterator;
 
        public:
            class iterator {
                T *ptr_;
 
            public:
                using iterator_category = std::random_access_iterator_tag;
                using value_type        = MultiArray<T, Rest...>;
                using difference_type   = ptrdiff_t;
                using pointer           = std::shared_ptr<value_type>;
                using reference         = value_type;
                explicit iterator(T *ptr) : ptr_(ptr) {}
                reference operator*() const { return reference(ptr_, true); }
                pointer   operator->() const {
                    return pointer(new value_type(ptr_, true));
                }
                iterator &operator++() {
                    ptr_ += SIZE / First;
                    return *this;
                }
                iterator operator++(int) {
                    auto tmp = *this;
                    ++*this;
                    return tmp;
                }
                iterator &operator--() {
                    ptr_ -= SIZE / First;
                    return *this;
                }
                iterator operator--(int) {
                    auto tmp = *this;
                    --*this;
                    return tmp;
                }
                reference operator[](difference_type n) const {
                    return reference(ptr_ + SIZE / First * n, true);
                }
                friend bool operator==(const iterator &a, const iterator &b) {
                    return a.ptr_ == b.ptr_;
                }
                friend bool operator!=(const iterator &a, const iterator &b) {
                    return a.ptr_ != b.ptr_;
                }
                friend bool operator<(const iterator &a, const iterator &b) {
                    return a.ptr_ < b.ptr_;
                }
                friend difference_type
                operator-(const iterator &a, const iterator &b) {
                    return (a.ptr_ - b.ptr_) / (SIZE / First);
                }
                friend iterator operator+(iterator it, difference_type n) {
                    it.ptr_ += n * (SIZE / First);
                    return it;
                }
                friend iterator operator+(difference_type n, iterator it) {
                    it.ptr_ += n * (SIZE / First);
                    return it;
                }
                iterator &operator+=(difference_type n) {
                    ptr_ += n * (SIZE / First);
                    return *this;
                }
                iterator &operator-=(difference_type n) {
                    ptr_ -= n * (SIZE / First);
                    return *this;
                }
            };

            class const_iterator {
                const T *ptr_;
 
            public:
                using iterator_category = std::random_access_iterator_tag;
                using value_type        = const MultiArray<T, Rest...>;
                using difference_type   = ptrdiff_t;
                using pointer           = std::shared_ptr<value_type>;
                using reference         = value_type;
                explicit const_iterator(const T *ptr) : ptr_(ptr) {}
                reference operator*() const { return reference(ptr_, true); }
                pointer   operator->() const {
                    return pointer(new value_type(ptr_, true));
                }
                const_iterator &operator++() {
                    ptr_ += SIZE / First;
                    return *this;
                }
                const_iterator operator++(int) {
                    auto tmp = *this;
                    ++*this;
                    return tmp;
                }
                const_iterator &operator--() {
                    ptr_ -= SIZE / First;
                    return *this;
                }
                const_iterator operator--(int) {
                    auto tmp = *this;
                    --*this;
                    return tmp;
                }
                reference operator[](difference_type n) const {
                    return reference(ptr_ + SIZE / First * n, true);
                }
                friend bool
                operator==(const const_iterator &a, const const_iterator &b) {
                    return a.ptr_ == b.ptr_;
                }
                friend bool
                operator!=(const const_iterator &a, const const_iterator &b) {
                    return a.ptr_ != b.ptr_;
                }
                friend bool
                operator<(const const_iterator &a, const const_iterator &b) {
                    return a.ptr_ < b.ptr_;
                }
                friend difference_type
                operator-(const const_iterator &a, const const_iterator &b) {
                    return (a.ptr_ - b.ptr_) / (SIZE / First);
                }
                friend const_iterator
                operator+(const_iterator it, difference_type n) {
                    it.ptr_ += n * (SIZE / First);
                    return it;
                }
                friend const_iterator
                operator+(difference_type n, const_iterator it) {
                    it.ptr_ += n * (SIZE / First);
                    return it;
                }
                const_iterator &operator+=(difference_type n) {
                    ptr_ += n * (SIZE / First);
                    return *this;
                }
                const_iterator &operator-=(difference_type n) {
                    ptr_ -= n * (SIZE / First);
                    return *this;
                }
            };
 
            using value_type       = MultiArray<T, Rest...>;
            using size_type        = size_t;
            using difference_type  = ptrdiff_t;
            using pointer          = value_type *;
            using const_pointer    = const value_type *;
            using reference        = value_type;       
            using const_reference  = const value_type; 
            using reverse_iterator = std::reverse_iterator<iterator>;
            using const_reverse_iterator
                = std::reverse_iterator<const_iterator>;

            MultiArray() : _multi_array_base<T>{new T[SIZE], false} {}

             */
            MultiArray(const T &value) :
                _multi_array_base<T>{new T[SIZE], false} {
                std::fill(data_, data_ + SIZE, value);
            }

             */
            MultiArray(std::initializer_list<T> init) :
                _multi_array_base<T>{new T[SIZE], false} {
                std::copy(init.begin(), init.end(), data_);
            }

             */
            MultiArray(std::initializer_list<MultiArray<T, Rest...>> init) :
                _multi_array_base<T>{new T[SIZE], false} {
                size_t offset = 0;
                for (const auto &sub : init) {
                    std::copy(sub.fbegin(), sub.fend(), data_ + offset);
                    offset += sub.fsize();
                }
            }

             */
            MultiArray(const MultiArray &other) :
                _multi_array_base<T>{new T[SIZE], false} {
                std::copy(other.data_, other.data_ + SIZE, data_);
            }

             */
            MultiArray(MultiArray &&other) noexcept :
                _multi_array_base<T>{other.data_, other.is_views_} {
                other.is_views_ = true;
            }

             */
            MultiArray &operator=(const MultiArray &other) {
                if (this != &other) {
                    if (!is_views_) delete[] data_;
                    data_ = new T[SIZE];
                    std::copy(other.data_, other.data_ + SIZE, data_);
                }
                return *this;
            }

             */
            MultiArray &operator=(MultiArray &&other) noexcept {
                if (this != &other) {
                    if (!is_views_) delete[] data_;
                    data_       = other.data_;
                    is_views_   = other.is_views_;
                    other.data_ = nullptr;
                }
                return *this;
            }

            MultiArray clone() const { return MultiArray(*this); }

            /// @brief 析构，拥有者释放堆内存，视图不释放。
            ~MultiArray() {
                if (!is_views_) delete[] data_;
            }

            /// @brief 迭代器 begin，返回指向首元素的迭代器。
            iterator begin() { //
                return iterator(data_);
            }
            /// @brief 迭代器 end，返回指向尾元素的迭代器。
            iterator end() { //
                return iterator(data_ + SIZE);
            }
            /// @brief const迭代器 begin，返回指向首元素的 const 迭代器。
            const_iterator begin() const { //
                return const_iterator(data_);
            }
            /// @brief const迭代器 end，返回指向尾元素的 const 迭代器。
            const_iterator end() const { //
                return const_iterator(data_ + SIZE);
            }
            /// @brief 反向迭代器 rbegin，返回指向尾元素的反向迭代器。
            reverse_iterator rbegin() { //
                return reverse_iterator(data_ + SIZE);
            }
            /// @brief 反向迭代器 rend，返回指向首元素的反向迭代器。
            reverse_iterator rend() { //
                return reverse_iterator(data_);
            }
            /// @brief const 反向迭代器 rbegin，返回指向尾元素的 const 反向迭代器。
            const_reverse_iterator rbegin() const {
                return const_reverse_iterator(data_ + SIZE);
            }
            /// @brief const 反向迭代器 rend，返回指向首元素的 const 反向迭代器。
            const_reverse_iterator rend() const {
                return const_reverse_iterator(data_);
            }
            /// @brief const 迭代器 cbegin，返回指向首元素的 const 迭代器。
            const_iterator cbegin() const { //
                return const_iterator(data_);
            }
            /// @brief const 迭代器 cend，返回指向尾元素的 const 迭代器。
            const_iterator cend() const { //
                return const_iterator(data_ + SIZE);
            }
            /// @brief const 反向迭代器 crbegin，返回指向尾元素的 const 反向迭代器。
            const_reverse_iterator crbegin() const {
                return const_reverse_iterator(data_ + SIZE);
            }
            /// @brief const 反向迭代器 crend，返回指向首元素的 const 反向迭代器。
            const_reverse_iterator crend() const {
                return const_reverse_iterator(data_);
            }

            T *fbegin() { return data_; }
            const T *fbegin() const { return data_; }
            T *fend() { return data_ + SIZE; }
            const T *fend() const { return data_ + SIZE; }

            static constexpr size_t rank() { return 1 + sizeof...(Rest); }
            /// @brief 静态成员函数 dims，返回数组的维度数组。
            static constexpr std::array<size_t, rank()> dims() {
                return {First, Rest...};
            }
            static constexpr size_t fsize() { return SIZE; }
            static constexpr bool fempty() { return SIZE == 0; }
            static constexpr size_t fmax_size() { return SIZE; }

             */
            MultiArray<T, SIZE> &flatten() {
                return *reinterpret_cast<MultiArray<T, SIZE> *>(this);
            }
             */
            const MultiArray<T, SIZE> &flatten() const {
                return *reinterpret_cast<const MultiArray<T, SIZE> *>(this);
            }

             */
            reference operator[](size_t index) {
                return reference(data_ + SIZE / First * index, true);
            }
             */
            const_reference operator[](size_t index) const {
                return const_reference(data_ + SIZE / First * index, true);
            }

             */
            reference at(size_t index) {
                if (index >= First)
                    throw MultiArrayError("index " + std::to_string(index)
                                          + " out of range [0, "
                                          + std::to_string(First) + ')');
                return operator[](index);
            }
             */
            const_reference at(size_t index) const {
                if (index >= First)
                    throw MultiArrayError("index " + std::to_string(index)
                                          + " out of range [0, "
                                          + std::to_string(First) + ')');
                return operator[](index);
            }

            reference operator()(size_t index) { return at(index); }
            const_reference operator()(size_t index) const { return at(index); }

            template <class... Indices>
            auto operator()(size_t idx, Indices... rest) //
                -> decltype(at(idx)(rest...)) {
                static_assert(
                    sizeof...(Indices) < rank(), "Too Many Arguments!");
                return at(idx)(rest...);
            }
            template <class... Indices>
            auto operator()(size_t idx, Indices... rest) const //
                -> decltype(at(idx)(rest...)) {
                static_assert(
                    sizeof...(Indices) < rank(), "Too Many Arguments!");
                return at(idx)(rest...);
            }

#if __cplusplus >= 202302L
            template <class... Indices>
            auto operator[](size_t idx, Indices... rest) //
                -> decltype(operator[](idx)[rest...]) {
                static_assert(
                    sizeof...(Indices) < rank(), "Too Many Arguments!");
                return operator[](idx)[rest...];
            }
            template <class... Indices>
            auto operator[](size_t idx, Indices... rest) const //
                -> decltype(operator[](idx)[rest...]) {
                static_assert(
                    sizeof...(Indices) < rank(), "Too Many Arguments!");
                return operator[](idx)[rest...];
            }
#endif

            reference front() { return operator[](0); }
            const_reference front() const { return operator[](0); }
            reference back() { return operator[](First - 1); }
            const_reference back() const { return operator[](First - 1); }

            static size_t size() { return First; }
            static bool empty() { return First == 0; }
            static size_t max_size() { return First; }

            template <class CharT, class Traits>
            friend std::basic_ostream<CharT, Traits> &operator<<(
                std::basic_ostream<CharT, Traits> &os, const MultiArray &ma) {
                if (ma.begin() == ma.end()) return os << "[]";
                auto it = ma.begin();
                os << '[';
                repr(*it, os);
                while (++it != ma.end()) {
                    os << ", ";
                    repr(*it, os);
                }
                return os << ']';
            }

            void fill(const T &value) { std::fill(data_, data_ + SIZE, value); }

            template <class F>
            void for_each(F f) {
                std::for_each(data_, data_ + SIZE, f);
            }

            template <class F>
            void for_each(F f) const {
                std::for_each(data_, data_ + SIZE, f);
            }

             */
            void swap(MultiArray &other) noexcept {
                std::swap(data_, other.data_);
                std::swap(is_views_, other.is_views_);
            }

             */
            friend void swap(MultiArray &a, MultiArray &b) noexcept {
                a.swap(b);
            }

            template <size_t... Dims>
            MultiArray<T, Dims...> &reshape() {
                static_assert(MultiArray<T, Dims...>::fsize() == fsize(),
                    "reshape: total element count must match");
                return *reinterpret_cast<MultiArray<T, Dims...> *>(this);
            }

            template <size_t... Dims>
            const MultiArray<T, Dims...> &reshape() const {
                static_assert(MultiArray<T, Dims...>::fsize() == fsize(),
                    "reshape: total element count must match");
                return *reinterpret_cast<const MultiArray<T, Dims...> *>(this);
            }
        };
    }
 
    // clang-format off
#define ARRAY_AND_ARRAY(OP)                                                    \
    template <class T, class U, size_t... Dims>                                \
    MultiArray<decltype(std::declval<T>() OP std::declval<U>()), Dims...>      \
    operator OP(const MultiArray<T, Dims...> &a,                               \
                const MultiArray<U, Dims...> &b) {                             \
        MultiArray<decltype(std::declval<T>() OP std::declval<U>()), Dims...>  \
            c;                                                                 \
        auto ai = a.fbegin();                                                  \
        auto bi = b.fbegin();                                                  \
        auto ci = c.fbegin();                                                  \
        while (ci != c.fend()) *ci++ = *ai++ OP *bi++;                         \
        return c;                                                              \
    }
 
#define ARRAY_AND_SCALAR(OP)                                                   \
    template <class T, class U, size_t... Dims>                                \
    MultiArray<decltype(std::declval<T>() OP std::declval<U>()), Dims...>      \
    operator OP(const MultiArray<T, Dims...> &a, const U &b) {                 \
        MultiArray<decltype(std::declval<T>() OP std::declval<U>()), Dims...>  \
            c;                                                                 \
        auto ai = a.fbegin();                                                  \
        auto ci = c.fbegin();                                                  \
        while (ci != c.fend()) *ci++ = *ai++ OP b;                             \
        return c;                                                              \
    }
 
#define SCALAR_AND_ARRAY(OP)                                                   \
    template <class T, class U, size_t... Dims>                                \
    MultiArray<decltype(std::declval<T>() OP std::declval<U>()), Dims...>      \
    operator OP(const U &a, const MultiArray<T, Dims...> &b) {                 \
        MultiArray<decltype(std::declval<T>() OP std::declval<U>()), Dims...>  \
            c;                                                                 \
        auto bi = b.fbegin();                                                  \
        auto ci = c.fbegin();                                                  \
        while (ci != c.fend()) *ci++ = a OP *bi++;                             \
        return c;                                                              \
    }
 
#define ARRAY_AND_ARRAY_INPLACE(OP)                                            \
    template <class T, class U, size_t... Dims>                                \
    MultiArray<T, Dims...> & operator OP(                                      \
            MultiArray<T, Dims...> &a,                                         \
            const MultiArray<U, Dims...> &b) {                                 \
        auto ai = a.fbegin();                                                  \
        auto bi = b.fbegin();                                                  \
        while (ai != a.fend()) *ai++ OP *bi++;                                 \
        return a;\
    }
 
#define ARRAY_AND_SCALAR_INPLACE(OP)                                           \
    template <class T, class U, size_t... Dims>                                \
    MultiArray<T, Dims...> & operator OP(MultiArray<T, Dims...> &a,            \
                                         const U &b) {                         \
        auto ai = a.fbegin();                                                  \
        while (ai != a.fend()) *ai++ OP b;                                     \
        return a;                                                              \
    }
 
#define ARRAY_AND_ARRAY_BOOL(OP)                                               \
    template <class T, class U, size_t... Dims>                                \
    MultiArray<bool, Dims...>                                                  \
    operator OP(const MultiArray<T, Dims...> &a,                               \
                const MultiArray<U, Dims...> &b) {                             \
        MultiArray<bool, Dims...> c;                                           \
        auto ai = a.fbegin();                                                  \
        auto bi = b.fbegin();                                                  \
        auto ci = c.fbegin();                                                  \
        while (ci != c.fend()) *ci++ = *ai++ OP *bi++;                         \
        return c;                                                              \
    }
 
#define ARRAY_AND_SCALAR_BOOL(OP)                                              \
    template <class T, class U, size_t... Dims>                                \
    MultiArray<bool, Dims...>                                                  \
    operator OP(const MultiArray<T, Dims...> &a, const U &b) {                 \
        MultiArray<bool, Dims...> c;                                           \
        auto ai = a.fbegin();                                                  \
        auto ci = c.fbegin();                                                  \
        while (ci != c.fend()) *ci++ = *ai++ OP b;                             \
        return c;                                                              \
    }
 
#define SCALAR_AND_ARRAY_BOOL(OP)                                              \
    template <class T, class U, size_t... Dims>                                \
    MultiArray<bool, Dims...>                                                  \
    operator OP(const U &a, const MultiArray<T, Dims...> &b) {                 \
        MultiArray<bool, Dims...> c;                                           \
        auto bi = b.fbegin();                                                  \
        auto ci = c.fbegin();                                                  \
        while (ci != c.fend()) *ci++ = a OP *bi++;                             \
        return c;                                                              \
    }
 
#define UNARY_ARRAY(OP)                                                        \
    template <class T, size_t... Dims>                                         \
    MultiArray<decltype(OP std::declval<T>()), Dims...>                        \
    operator OP(const MultiArray<T, Dims...> &a) {                             \
        MultiArray<decltype(OP std::declval<T>()), Dims...> c;                 \
        auto ai = a.fbegin();                                                  \
        auto ci = c.fbegin();                                                  \
        while (ci != c.fend()) *ci++ = OP *ai++;                               \
        return c;                                                              \
    }
 
#define UNARY_ARRAY_BOOL(OP)                                                   \
    template <class T, size_t... Dims>                                         \
    MultiArray<bool, Dims...>                                                  \
    operator OP(const MultiArray<T, Dims...> &a) {                             \
        MultiArray<bool, Dims...> c;                                           \
        auto ai = a.fbegin();                                                  \
        auto ci = c.fbegin();                                                  \
        while (ci != c.fend()) *ci++ = OP *ai++;                               \
        return c;                                                              \
    }
    // clang-format on
 
    ARRAY_AND_ARRAY(+)
    ARRAY_AND_ARRAY(-)
    ARRAY_AND_ARRAY(*)
    ARRAY_AND_ARRAY(/)
    ARRAY_AND_ARRAY(%)
 
    ARRAY_AND_ARRAY_INPLACE(+=)
    ARRAY_AND_ARRAY_INPLACE(-=)
    ARRAY_AND_ARRAY_INPLACE(*=)
    ARRAY_AND_ARRAY_INPLACE(/=)
    ARRAY_AND_ARRAY_INPLACE(%=)
 
    ARRAY_AND_SCALAR_INPLACE(+=)
    ARRAY_AND_SCALAR_INPLACE(-=)
    ARRAY_AND_SCALAR_INPLACE(*=)
    ARRAY_AND_SCALAR_INPLACE(/=)
    ARRAY_AND_SCALAR_INPLACE(%=)
 
    ARRAY_AND_ARRAY_BOOL(==)
    ARRAY_AND_ARRAY_BOOL(!=)
    ARRAY_AND_ARRAY_BOOL(<)
    ARRAY_AND_ARRAY_BOOL(>)
    ARRAY_AND_ARRAY_BOOL(<=)
    ARRAY_AND_ARRAY_BOOL(>=)
 
    ARRAY_AND_SCALAR(+)
    ARRAY_AND_SCALAR(-)
    ARRAY_AND_SCALAR(*)
    ARRAY_AND_SCALAR(/)
    ARRAY_AND_SCALAR(%)
 
    SCALAR_AND_ARRAY(+)
    SCALAR_AND_ARRAY(-)
    SCALAR_AND_ARRAY(*)
    SCALAR_AND_ARRAY(/)
    SCALAR_AND_ARRAY(%)
 
    UNARY_ARRAY(+)
    UNARY_ARRAY(-)
    UNARY_ARRAY(~)
 
    UNARY_ARRAY_BOOL(!)
 
    ARRAY_AND_SCALAR_BOOL(==)
    ARRAY_AND_SCALAR_BOOL(!=)
    ARRAY_AND_SCALAR_BOOL(<)
    ARRAY_AND_SCALAR_BOOL(>)
    ARRAY_AND_SCALAR_BOOL(<=)
    ARRAY_AND_SCALAR_BOOL(>=)
 
    SCALAR_AND_ARRAY_BOOL(==)
    SCALAR_AND_ARRAY_BOOL(!=)
    SCALAR_AND_ARRAY_BOOL(<)
    SCALAR_AND_ARRAY_BOOL(>)
    SCALAR_AND_ARRAY_BOOL(<=)
    SCALAR_AND_ARRAY_BOOL(>=)
 
    ARRAY_AND_ARRAY_BOOL(&&)
    ARRAY_AND_ARRAY_BOOL(||)
 
    ARRAY_AND_SCALAR_BOOL(&&)
    ARRAY_AND_SCALAR_BOOL(||)
 
    SCALAR_AND_ARRAY_BOOL(&&)
    SCALAR_AND_ARRAY_BOOL(||)
 
    ARRAY_AND_ARRAY(&)
    ARRAY_AND_ARRAY(|)
    ARRAY_AND_ARRAY(^)
    ARRAY_AND_ARRAY(<<)
    ARRAY_AND_ARRAY(>>)
 
    ARRAY_AND_ARRAY_INPLACE(&=)
    ARRAY_AND_ARRAY_INPLACE(|=)
    ARRAY_AND_ARRAY_INPLACE(^=)
    ARRAY_AND_ARRAY_INPLACE(<<=)
    ARRAY_AND_ARRAY_INPLACE(>>=)
 
    ARRAY_AND_SCALAR(&)
    ARRAY_AND_SCALAR(|)
    ARRAY_AND_SCALAR(^)
    ARRAY_AND_SCALAR(<<)
    ARRAY_AND_SCALAR(>>)
 
    SCALAR_AND_ARRAY(&)
    SCALAR_AND_ARRAY(|)
    SCALAR_AND_ARRAY(^)
    SCALAR_AND_ARRAY(>>)
 
    // SCALAR_AND_ARRAY(<<)
    template <class T, class U, size_t... Dims>
    typename std::enable_if<!std::is_base_of<std::ios_base, U>::value,
        MultiArray<decltype(std::declval<U>() << std::declval<T>()),
            Dims...>>::type
    operator<<(const U &value, const MultiArray<T, Dims...> &a) {
        MultiArray<decltype(std::declval<U>() << std::declval<T>()), Dims...> b;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        while (bi != b.fend()) *bi++ = value << *ai++;
        return b;
    }
 
    ARRAY_AND_SCALAR_INPLACE(&=)
    ARRAY_AND_SCALAR_INPLACE(|=)
    ARRAY_AND_SCALAR_INPLACE(^=)
    ARRAY_AND_SCALAR_INPLACE(<<=)
    ARRAY_AND_SCALAR_INPLACE(>>=)
 
#undef ARRAY_AND_ARRAY
#undef ARRAY_AND_SCALAR
#undef SCALAR_AND_ARRAY
#undef ARRAY_AND_ARRAY_INPLACE
#undef ARRAY_AND_SCALAR_INPLACE
#undef ARRAY_AND_ARRAY_BOOL
#undef ARRAY_AND_SCALAR_BOOL
#undef SCALAR_AND_ARRAY_BOOL
#undef UNARY_ARRAY
#undef UNARY_ARRAY_BOOL

    template <class T, size_t... Dims>
    T sum(const MultiArray<T, Dims...> &a) {
        T result{};
        a.for_each([&](const T &ref) { result += ref; });
        return result;
    }

    template <class T, size_t... Dims>
    T min(const MultiArray<T, Dims...> &a) {
        return *std::min_element(a.fbegin(), a.fend());
    }

    template <class T, size_t... Dims>
    T max(const MultiArray<T, Dims...> &a) {
        return *std::max_element(a.fbegin(), a.fend());
    }

    template <class T, size_t... Dims>
    bool all(const MultiArray<T, Dims...> &a) {
        for (auto it = a.fbegin(); it != a.fend(); ++it)
            if (!*it) return false;
        return true;
    }

    template <class T, size_t... Dims>
    bool any(const MultiArray<T, Dims...> &a) {
        for (auto it = a.fbegin(); it != a.fend(); ++it)
            if (*it) return true;
        return false;
    }

    template <class T, class U, size_t... Dims>
    bool
    equals(const MultiArray<T, Dims...> &a, const MultiArray<U, Dims...> &b) {
        for (size_t i = 0; i < a.fsize(); ++i)
            if (a[i] != b[i]) return false;
        return true;
    }

    template <class T, class U, size_t... Dims1, size_t... Dims2>
    constexpr bool
    equals(const MultiArray<T, Dims1...> &, const MultiArray<U, Dims2...> &) {
        return false;
    }

    template <class T, class U, size_t... Dims, class Op>
    bool equals(const MultiArray<T, Dims...> &a,
        const MultiArray<U, Dims...>         &b,
        Op                                  &&op) {
        for (size_t i = 0; i < a.fsize(); ++i)
            if (!op(a[i], b[i])) return false;
        return true;
    }

    template <class T, class U, size_t... Dims1, size_t... Dims2, class Op>
    constexpr bool equals(const MultiArray<T, Dims1...> &,
        const MultiArray<U, Dims2...> &,
        Op &&) {
        return false;
    }

    template <class T, class U, size_t... Dims>
    int
    compare(const MultiArray<T, Dims...> &a, const MultiArray<U, Dims...> &b) {
        for (auto it1 = a.fbegin(), it2 = b.fbegin(); //
            it1 != a.fend();                          //
            ++it1, ++it2) {
            if (*it1 < *it2) return -1;
            if (*it2 < *it1) return 1;
        }
        return 0;
    }
}