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 <iostream>
#include <array>
#include <cstddef>
#include <stdexcept>
#include <type_traits>
#include <initializer_list>
#include <algorithm>
#include <cstring>
#include "csexc.h"
#include "repr.h"
 
namespace console
{
    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 multiarray_error(
                    "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 multiarray_error(
                    "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 <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 = T;
        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 multiarray_error(
                    "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 multiarray_error(
                    "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 multiarray_error(
                    "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 multiarray_error(
                    "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 *(MultiArray<T, fsize()> *)this;
        }

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

        static constexpr std::array<size_t, rank()> dims()
        {
            return {First, Rest...};
        }
    };
 
    // ========================== 运算符重载（数组与数组） ==========================

    template <class T, size_t... Dims>
    MultiArray<T, Dims...> operator+(const MultiArray<T, Dims...> &a,
                                     const MultiArray<T, Dims...> &b)
    {
        MultiArray<T, Dims...> c;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        auto ci = c.fbegin();
        while (ci != c.fend())
            *ci++ = *ai++ + *bi++;
        return c;
    }

    template <class T, size_t... Dims>
    MultiArray<T, Dims...> operator-(const MultiArray<T, Dims...> &a,
                                     const MultiArray<T, Dims...> &b)
    {
        MultiArray<T, Dims...> c;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        auto ci = c.fbegin();
        while (ci != c.fend())
            *ci++ = *ai++ - *bi++;
        return c;
    }

    template <class T, size_t... Dims>
    MultiArray<T, Dims...> operator*(const MultiArray<T, Dims...> &a,
                                     const MultiArray<T, Dims...> &b)
    {
        MultiArray<T, Dims...> c;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        auto ci = c.fbegin();
        while (ci != c.fend())
            *ci++ = *ai++ * *bi++;
        return c;
    }

    template <class T, size_t... Dims>
    MultiArray<T, Dims...> operator/(const MultiArray<T, Dims...> &a,
                                     const MultiArray<T, Dims...> &b)
    {
        MultiArray<T, Dims...> c;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        auto ci = c.fbegin();
        while (ci != c.fend())
            *ci++ = *ai++ / *bi++;
        return c;
    }

    template <class T, size_t... Dims>
    MultiArray<T, Dims...> operator%(const MultiArray<T, Dims...> &a,
                                     const MultiArray<T, Dims...> &b)
    {
        MultiArray<T, Dims...> c;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        auto ci = c.fbegin();
        while (ci != c.fend())
            *ci++ = *ai++ % *bi++;
        return c;
    }

    template <class T, size_t... Dims>
    MultiArray<T, Dims...> &operator+=(MultiArray<T, Dims...> &a,
                                       const MultiArray<T, Dims...> &b)
    {
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        while (ai != a.fend())
            *ai++ += *bi++;
        return a;
    }

    template <class T, size_t... Dims>
    MultiArray<T, Dims...> &operator-=(MultiArray<T, Dims...> &a,
                                       const MultiArray<T, Dims...> &b)
    {
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        while (ai != a.fend())
            *ai++ -= *bi++;
        return a;
    }

    template <class T, size_t... Dims>
    MultiArray<T, Dims...> &operator*=(MultiArray<T, Dims...> &a,
                                       const MultiArray<T, Dims...> &b)
    {
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        while (ai != a.fend())
            *ai++ *= *bi++;
        return a;
    }

    template <class T, size_t... Dims>
    MultiArray<T, Dims...> &operator/=(MultiArray<T, Dims...> &a,
                                       const MultiArray<T, Dims...> &b)
    {
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        while (ai != a.fend())
            *ai++ /= *bi++;
        return a;
    }

    template <class T, size_t... Dims>
    MultiArray<T, Dims...> &operator%=(MultiArray<T, Dims...> &a,
                                       const MultiArray<T, Dims...> &b)
    {
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        while (ai != a.fend())
            *ai++ %= *bi++;
        return a;
    }

    template <class T, size_t... Dims>
    MultiArray<bool, Dims...> operator==(const MultiArray<T, Dims...> &a,
                                         const MultiArray<T, Dims...> &b)
    {
        MultiArray<bool, Dims...> c;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        auto ci = c.fbegin();
        while (ci != c.fend())
            *ci++ = *ai++ == *bi++;
        return c;
    }

    template <class T, size_t... Dims>
    MultiArray<bool, Dims...> operator!=(const MultiArray<T, Dims...> &a,
                                         const MultiArray<T, Dims...> &b)
    {
        MultiArray<bool, Dims...> c;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        auto ci = c.fbegin();
        while (ci != c.fend())
            *ci++ = *ai++ != *bi++;
        return c;
    }

    template <class T, size_t... Dims>
    MultiArray<bool, Dims...> operator<(const MultiArray<T, Dims...> &a,
                                        const MultiArray<T, Dims...> &b)
    {
        MultiArray<bool, Dims...> c;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        auto ci = c.fbegin();
        while (ci != c.fend())
            *ci++ = *ai++ < *bi++;
        return c;
    }

    template <class T, size_t... Dims>
    MultiArray<bool, Dims...> operator>(const MultiArray<T, Dims...> &a,
                                        const MultiArray<T, Dims...> &b)
    {
        MultiArray<bool, Dims...> c;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        auto ci = c.fbegin();
        while (ci != c.fend())
            *ci++ = *ai++ > *bi++;
        return c;
    }

    template <class T, size_t... Dims>
    MultiArray<bool, Dims...> operator<=(const MultiArray<T, Dims...> &a,
                                         const MultiArray<T, Dims...> &b)
    {
        MultiArray<bool, Dims...> c;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        auto ci = c.fbegin();
        while (ci != c.fend())
            *ci++ = *ai++ <= *bi++;
        return c;
    }

    template <class T, size_t... Dims>
    MultiArray<bool, Dims...> operator>=(const MultiArray<T, Dims...> &a,
                                         const MultiArray<T, Dims...> &b)
    {
        MultiArray<bool, Dims...> c;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        auto ci = c.fbegin();
        while (ci != c.fend())
            *ci++ = *ai++ >= *bi++;
        return c;
    }
 
    // 算术运算符（数组与标量）
    template <class T, size_t... Dims, class U>
    MultiArray<T, Dims...> operator+(const MultiArray<T, Dims...> &a,
                                     const U &value)
    {
        MultiArray<T, Dims...> b;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        while (bi != b.fend())
            *bi++ = *ai++ + value;
        return b;
    }

    template <class T, size_t... Dims, class U>
    MultiArray<T, Dims...> operator-(const MultiArray<T, Dims...> &a,
                                     const U &value)
    {
        MultiArray<T, Dims...> b;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        while (bi != b.fend())
            *bi++ = *ai++ - value;
        return b;
    }

    template <class T, size_t... Dims, class U>
    MultiArray<T, Dims...> operator*(const MultiArray<T, Dims...> &a,
                                     const U &value)
    {
        MultiArray<T, Dims...> b;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        while (bi != b.fend())
            *bi++ = *ai++ * value;
        return b;
    }

    template <class T, size_t... Dims, class U>
    MultiArray<T, Dims...> operator/(const MultiArray<T, Dims...> &a,
                                     const U &value)
    {
        MultiArray<T, Dims...> b;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        while (bi != b.fend())
            *bi++ = *ai++ / value;
        return b;
    }

    template <class T, size_t... Dims, class U>
    MultiArray<T, Dims...> operator%(const MultiArray<T, Dims...> &a,
                                     const U &value)
    {
        MultiArray<T, Dims...> b;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        while (bi != b.fend())
            *bi++ = *ai++ % value;
        return b;
    }

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

    template <class T, size_t... Dims, class U>
    MultiArray<T, Dims...> &operator-=(MultiArray<T, Dims...> &a,
                                       const U &value)
    {
        a.for_each([&](T &ref)
                   { ref -= value; });
        return a;
    }

    template <class T, size_t... Dims, class U>
    MultiArray<T, Dims...> &operator*=(MultiArray<T, Dims...> &a,
                                       const U &value)
    {
        a.for_each([&](T &ref)
                   { ref *= value; });
        return a;
    }

    template <class T, size_t... Dims, class U>
    MultiArray<T, Dims...> &operator/=(MultiArray<T, Dims...> &a,
                                       const U &value)
    {
        a.for_each([&](T &ref)
                   { ref /= value; });
        return a;
    }

    template <class T, size_t... Dims, class U>
    MultiArray<T, Dims...> &operator%=(MultiArray<T, Dims...> &a,
                                       const U &value)
    {
        a.for_each([&](T &ref)
                   { ref %= value; });
        return a;
    }
 
    // 算术运算符（标量与数组）
    template <class T, size_t... Dims, class U>
    MultiArray<T, Dims...> operator+(const U &value,
                                     const MultiArray<T, Dims...> &a)
    {
        return a + value;
    }

    template <class T, size_t... Dims, class U>
    MultiArray<T, Dims...> operator-(const U &value,
                                     const MultiArray<T, Dims...> &a)
    {
        MultiArray<T, Dims...> b;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        while (bi != b.fend())
            *bi++ = value - *ai++;
        return b;
    }

    template <class T, size_t... Dims, class U>
    MultiArray<T, Dims...> operator*(const U &value,
                                     const MultiArray<T, Dims...> &a)
    {
        return a * value;
    }

    template <class T, size_t... Dims, class U>
    MultiArray<T, Dims...> operator/(const U &value,
                                     const MultiArray<T, Dims...> &a)
    {
        MultiArray<T, Dims...> b;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        while (bi != b.fend())
            *bi++ = value / *ai++;
        return b;
    }

    template <class T, size_t... Dims, class U>
    MultiArray<T, Dims...> operator%(const U &value,
                                     const MultiArray<T, Dims...> &a)
    {
        MultiArray<T, Dims...> b;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        while (bi != b.fend())
            *bi++ = value % *ai++;
        return b;
    }
 
    // 一元运算符
    template <class T, size_t... Dims>
    MultiArray<T, Dims...> operator+(const MultiArray<T, Dims...> &a)
    {
        return a;
    }

    template <class T, size_t... Dims>
    MultiArray<T, Dims...> operator-(const MultiArray<T, Dims...> &a)
    {
        MultiArray<T, Dims...> b;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        while (bi != b.fend())
            *bi++ = -*ai++;
        return b;
    }

    template <class T, size_t... Dims>
    MultiArray<bool, Dims...> operator!(const MultiArray<T, Dims...> &a)
    {
        MultiArray<bool, Dims...> b;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        while (bi != b.fend())
            *bi++ = !*ai++;
        return b;
    }

    template <class T, size_t... Dims>
    MultiArray<T, Dims...> operator~(const MultiArray<T, Dims...> &a)
    {
        MultiArray<T, Dims...> b;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        while (bi != b.fend())
            *bi++ = ~*ai++;
        return b;
    }
 
    // 比较运算符（数组与标量）
    template <class T, size_t... Dims, class U>
    MultiArray<bool, Dims...> operator==(const MultiArray<T, Dims...> &a,
                                         const U &value)
    {
        MultiArray<bool, Dims...> b;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        while (bi != b.fend())
            *bi++ = *ai++ == value;
        return b;
    }

    template <class T, size_t... Dims, class U>
    MultiArray<bool, Dims...> operator!=(const MultiArray<T, Dims...> &a,
                                         const U &value)
    {
        MultiArray<bool, Dims...> b;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        while (bi != b.fend())
            *bi++ = *ai++ != value;
        return b;
    }

    template <class T, size_t... Dims, class U>
    MultiArray<bool, Dims...> operator<(const MultiArray<T, Dims...> &a,
                                        const U &value)
    {
        MultiArray<bool, Dims...> b;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        while (bi != b.fend())
            *bi++ = *ai++ < value;
        return b;
    }

    template <class T, size_t... Dims, class U>
    MultiArray<bool, Dims...> operator>(const MultiArray<T, Dims...> &a,
                                        const U &value)
    {
        MultiArray<bool, Dims...> b;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        while (bi != b.fend())
            *bi++ = *ai++ > value;
        return b;
    }

    template <class T, size_t... Dims, class U>
    MultiArray<bool, Dims...> operator<=(const MultiArray<T, Dims...> &a,
                                         const U &value)
    {
        MultiArray<bool, Dims...> b;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        while (bi != b.fend())
            *bi++ = *ai++ <= value;
        return b;
    }

    template <class T, size_t... Dims, class U>
    MultiArray<bool, Dims...> operator>=(const MultiArray<T, Dims...> &a,
                                         const U &value)
    {
        MultiArray<bool, Dims...> b;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        while (bi != b.fend())
            *bi++ = *ai++ >= value;
        return b;
    }
 
    // 比较运算符（标量与数组）
    template <class T, size_t... Dims, class U>
    MultiArray<bool, Dims...> operator==(const U &value,
                                         const MultiArray<T, Dims...> &a)
    {
        return a == value;
    }

    template <class T, size_t... Dims, class U>
    MultiArray<bool, Dims...> operator!=(const U &value,
                                         const MultiArray<T, Dims...> &a)
    {
        return a != value;
    }

    template <class T, size_t... Dims, class U>
    MultiArray<bool, Dims...> operator<(const U &value,
                                        const MultiArray<T, Dims...> &a)
    {
        return a > value;
    }

    template <class T, size_t... Dims, class U>
    MultiArray<bool, Dims...> operator>(const U &value,
                                        const MultiArray<T, Dims...> &a)
    {
        return a < value;
    }

    template <class T, size_t... Dims, class U>
    MultiArray<bool, Dims...> operator<=(const U &value,
                                         const MultiArray<T, Dims...> &a)
    {
        return a >= value;
    }

    template <class T, size_t... Dims, class U>
    MultiArray<bool, Dims...> operator>=(const U &value,
                                         const MultiArray<T, Dims...> &a)
    {
        return a <= value;
    }
 
    // 逻辑运算符（数组与数组）
    template <class T, size_t... Dims>
    MultiArray<bool, Dims...> operator&&(const MultiArray<T, Dims...> &a,
                                         const MultiArray<T, Dims...> &b)
    {
        MultiArray<bool, Dims...> c;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        auto ci = c.fbegin();
        while (ci != c.fend())
            *ci++ = *ai++ && *bi++;
        return c;
    }

    template <class T, size_t... Dims>
    MultiArray<bool, Dims...> operator||(const MultiArray<T, Dims...> &a,
                                         const MultiArray<T, Dims...> &b)
    {
        MultiArray<bool, Dims...> c;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        auto ci = c.fbegin();
        while (ci != c.fend())
            *ci++ = *ai++ || *bi++;
        return c;
    }
 
    // 逻辑运算符（数组与标量）
    template <class T, size_t... Dims, class U>
    MultiArray<bool, Dims...> operator&&(const MultiArray<T, Dims...> &a,
                                         const U &value)
    {
        MultiArray<bool, Dims...> b;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        while (bi != b.fend())
            *bi++ = *ai++ && value;
        return b;
    }

    template <class T, size_t... Dims, class U>
    MultiArray<bool, Dims...> operator||(const MultiArray<T, Dims...> &a,
                                         const U &value)
    {
        MultiArray<bool, Dims...> b;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        while (bi != b.fend())
            *bi++ = *ai++ || value;
        return b;
    }

    template <class T, size_t... Dims, class U>
    MultiArray<bool, Dims...> operator&&(const U &value,
                                         const MultiArray<T, Dims...> &a)
    {
        return a && value;
    }

    template <class T, size_t... Dims, class U>
    MultiArray<bool, Dims...> operator||(const U &value,
                                         const MultiArray<T, Dims...> &a)
    {
        return a || value;
    }
 
    // 位运算符（数组与数组）
    template <class T, size_t... Dims>
    MultiArray<T, Dims...> operator&(const MultiArray<T, Dims...> &a,
                                     const MultiArray<T, Dims...> &b)
    {
        MultiArray<T, Dims...> c;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        auto ci = c.fbegin();
        while (ci != c.fend())
            *ci++ = *ai++ & *bi++;
        return c;
    }

    template <class T, size_t... Dims>
    MultiArray<T, Dims...> operator|(const MultiArray<T, Dims...> &a,
                                     const MultiArray<T, Dims...> &b)
    {
        MultiArray<T, Dims...> c;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        auto ci = c.fbegin();
        while (ci != c.fend())
            *ci++ = *ai++ | *bi++;
        return c;
    }

    template <class T, size_t... Dims>
    MultiArray<T, Dims...> operator^(const MultiArray<T, Dims...> &a,
                                     const MultiArray<T, Dims...> &b)
    {
        MultiArray<T, Dims...> c;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        auto ci = c.fbegin();
        while (ci != c.fend())
            *ci++ = *ai++ ^ *bi++;
        return c;
    }

    template <class T, size_t... Dims>
    MultiArray<T, Dims...> operator<<(const MultiArray<T, Dims...> &a,
                                      const MultiArray<T, Dims...> &b)
    {
        MultiArray<T, Dims...> c;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        auto ci = c.fbegin();
        while (ci != c.fend())
            *ci++ = *ai++ << *bi++;
        return c;
    }

    template <class T, size_t... Dims>
    MultiArray<T, Dims...> operator>>(const MultiArray<T, Dims...> &a,
                                      const MultiArray<T, Dims...> &b)
    {
        MultiArray<T, Dims...> c;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        auto ci = c.fbegin();
        while (ci != c.fend())
            *ci++ = *ai++ >> *bi++;
        return c;
    }

    template <class T, size_t... Dims>
    MultiArray<T, Dims...> &operator&=(MultiArray<T, Dims...> &a,
                                       const MultiArray<T, Dims...> &b)
    {
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        while (ai != a.fend())
            *ai++ &= *bi++;
        return a;
    }

    template <class T, size_t... Dims>
    MultiArray<T, Dims...> &operator|=(MultiArray<T, Dims...> &a,
                                       const MultiArray<T, Dims...> &b)
    {
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        while (ai != a.fend())
            *ai++ |= *bi++;
        return a;
    }

    template <class T, size_t... Dims>
    MultiArray<T, Dims...> &operator^=(MultiArray<T, Dims...> &a,
                                       const MultiArray<T, Dims...> &b)
    {
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        while (ai != a.fend())
            *ai++ ^= *bi++;
        return a;
    }

    template <class T, size_t... Dims>
    MultiArray<T, Dims...> &operator<<=(MultiArray<T, Dims...> &a,
                                        const MultiArray<T, Dims...> &b)
    {
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        while (ai != a.fend())
            *ai++ <<= *bi++;
        return a;
    }

    template <class T, size_t... Dims>
    MultiArray<T, Dims...> &operator>>=(MultiArray<T, Dims...> &a,
                                        const MultiArray<T, Dims...> &b)
    {
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        while (ai != a.fend())
            *ai++ >>= *bi++;
        return a;
    }
 
    // 位运算符（数组与标量）
    template <class T, size_t... Dims, class U>
    MultiArray<T, Dims...> operator&(const MultiArray<T, Dims...> &a,
                                     const U &value)
    {
        MultiArray<T, Dims...> b;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        while (bi != b.fend())
            *bi++ = *ai++ & value;
        return b;
    }

    template <class T, size_t... Dims, class U>
    MultiArray<T, Dims...> operator|(const MultiArray<T, Dims...> &a,
                                     const U &value)
    {
        MultiArray<T, Dims...> b;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        while (bi != b.fend())
            *bi++ = *ai++ | value;
        return b;
    }

    template <class T, size_t... Dims, class U>
    MultiArray<T, Dims...> operator^(const MultiArray<T, Dims...> &a,
                                     const U &value)
    {
        MultiArray<T, Dims...> b;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        while (bi != b.fend())
            *bi++ = *ai++ ^ value;
        return b;
    }

    template <class T, size_t... Dims, class U>
    MultiArray<T, Dims...> operator<<(const MultiArray<T, Dims...> &a,
                                      const U &value)
    {
        MultiArray<T, Dims...> b;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        while (bi != b.fend())
            *bi++ = *ai++ << value;
        return b;
    }

    template <class T, size_t... Dims, class U>
    MultiArray<T, Dims...> operator>>(const MultiArray<T, Dims...> &a,
                                      const U &value)
    {
        MultiArray<T, Dims...> b;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        while (bi != b.fend())
            *bi++ = *ai++ >> value;
        return b;
    }

    template <class T, size_t... Dims, class U>
    MultiArray<T, Dims...> operator&(const U &value,
                                     const MultiArray<T, Dims...> &a)
    {
        return a & value;
    }

    template <class T, size_t... Dims, class U>
    MultiArray<T, Dims...> operator|(const U &value,
                                     const MultiArray<T, Dims...> &a)
    {
        return a | value;
    }

    template <class T, size_t... Dims, class U>
    MultiArray<T, Dims...> operator^(const U &value,
                                     const MultiArray<T, Dims...> &a)
    {
        return a ^ value;
    }

    template <class T, size_t... Dims, class U>
    MultiArray<T, Dims...> operator<<(const U &value,
                                      const MultiArray<T, Dims...> &a)
    {
        MultiArray<T, Dims...> b;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        while (bi != b.fend())
            *bi++ = value << *ai++;
        return b;
    }

    template <class T, size_t... Dims, class U>
    MultiArray<T, Dims...> operator>>(const U &value,
                                      const MultiArray<T, Dims...> &a)
    {
        MultiArray<T, Dims...> b;
        auto ai = a.fbegin();
        auto bi = b.fbegin();
        while (bi != b.fend())
            *bi++ = value >> *ai++;
        return b;
    }

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

    template <class T, size_t... Dims, class U>
    MultiArray<T, Dims...> &operator|=(MultiArray<T, Dims...> &a,
                                       const U &value)
    {
        a.for_each([&](T &ref)
                   { ref |= value; });
        return a;
    }

    template <class T, size_t... Dims, class U>
    MultiArray<T, Dims...> &operator^=(MultiArray<T, Dims...> &a,
                                       const U &value)
    {
        a.for_each([&](T &ref)
                   { ref ^= value; });
        return a;
    }

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

    template <class T, size_t... Dims, class U>
    MultiArray<T, Dims...> &operator>>=(MultiArray<T, Dims...> &a,
                                        const U &value)
    {
        a.for_each([&](T &ref)
                   { ref >>= value; });
        return a;
    }
 // end of multiarray_ops
 
    // ========================== 统计函数 ==========================

    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;
    }
 // end of multiarray_stats
 
    // ========================== 类型转换 ==========================

    template <size_t... OutArrDims, class VarType, size_t... InArrDims>
    MultiArray<VarType, OutArrDims...> multiarray_cast(
        const MultiArray<VarType, InArrDims...> &inputArr)
    {
        static_assert(MultiArray<VarType, OutArrDims...>::fsize() ==
                          MultiArray<VarType, InArrDims...>::fsize(),
                      "Bad multiarray_cast: Mismatch Size");
        MultiArray<VarType, OutArrDims...> outputArr;
        std::copy(inputArr.fbegin(), inputArr.fend(), outputArr.fbegin());
        return outputArr;
    }

    template <class OutType, size_t... OutArrDims,
              class InType, size_t... InArrDims>
    MultiArray<OutType, OutArrDims...> unsafe_multiarray_cast(
        const MultiArray<InType, InArrDims...> &inputArr)
    {
        MultiArray<OutType, OutArrDims...> outputArr;
        memcpy(&outputArr, &inputArr, sizeof(outputArr));
        return outputArr;
    }

    template <size_t... OutArrDims, class VarType, size_t... InArrDims>
    MultiArray<VarType, OutArrDims...> &inplace_multiarray_cast(
        MultiArray<VarType, InArrDims...> &inputArr)
    {
        static_assert(MultiArray<VarType, OutArrDims...>::fsize() ==
                          MultiArray<VarType, InArrDims...>::fsize(),
                      "Bad inplace_multiarray_cast: Mismatch Size");
        auto p = (MultiArray<VarType, OutArrDims...> *)&inputArr;
        return *p;
    }

    template <size_t... OutArrDims, class VarType, size_t... InArrDims>
    const MultiArray<VarType, OutArrDims...> &inplace_multiarray_cast(
        const MultiArray<VarType, InArrDims...> &inputArr)
    {
        static_assert(MultiArray<VarType, OutArrDims...>::fsize() ==
                          MultiArray<VarType, InArrDims...>::fsize(),
                      "Bad inplace_multiarray_cast: Mismatch Size");
        auto p = (const MultiArray<VarType, OutArrDims...> *)&inputArr;
        return *p;
    }
 // end of multiarray_cast
}