NdArrayOperators.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <algorithm>
#include <cmath>
#include <complex>
#include <functional>
 
#include "NumCpp/Core/Internal/Error.hpp"
#include "NumCpp/Core/Internal/StaticAsserts.hpp"
#include "NumCpp/Core/Internal/StdComplexOperators.hpp"
#include "NumCpp/Core/Internal/StlAlgorithms.hpp"
#include "NumCpp/Core/Internal/TypeTraits.hpp"
#include "NumCpp/Functions/complex.hpp"
#include "NumCpp/NdArray/NdArrayBroadcast.hpp"
#include "NumCpp/NdArray/NdArrayCore.hpp"
#include "NumCpp/Utils/essentiallyEqual.hpp"
#include "NumCpp/Utils/essentiallyEqualComplex.hpp"
 
namespace nc
{
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype>& operator+=(NdArray<dtype>& lhs, const NdArray<dtype>& rhs)
    {
        STATIC_ASSERT_ARITHMETIC_OR_COMPLEX(dtype);
 
        return broadcast::broadcaster(lhs, rhs, std::plus<dtype>());
    }
    NdArray<dtype>& operator+=(NdArray<dtype>& lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<std::complex<dtype>>& operator+=(NdArray<std::complex<dtype>>& lhs, const NdArray<dtype>& rhs)
    {
        STATIC_ASSERT_ARITHMETIC(dtype);
 
        const auto function = [](const std::complex<dtype>& val1, dtype val2) -> std::complex<dtype>
        { return val1 + val2; };
        return broadcast::broadcaster(lhs, rhs, function);
    }
    NdArray<std::complex<dtype>>& operator+=(NdArray<std::complex<dtype>>& lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype>& operator+=(NdArray<dtype>& lhs, dtype rhs)
    {
        STATIC_ASSERT_ARITHMETIC_OR_COMPLEX(dtype);
 
        const auto function = [rhs](dtype& value) -> dtype { return value += rhs; };
 
        stl_algorithms::for_each(lhs.begin(), lhs.end(), function);
 
        return lhs;
    }
    NdArray<dtype>& operator+=(NdArray<dtype>& lhs, dtype rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<std::complex<dtype>>& operator+=(NdArray<std::complex<dtype>>& lhs, dtype rhs)
    {
        STATIC_ASSERT_ARITHMETIC(dtype);
 
        const auto function = [rhs](std::complex<dtype>& value) -> std::complex<dtype> { return value += rhs; };
 
        stl_algorithms::for_each(lhs.begin(), lhs.end(), function);
 
        return lhs;
    }
    NdArray<std::complex<dtype>>& operator+=(NdArray<std::complex<dtype>>& lhs, dtype rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype> operator+(const NdArray<dtype>& lhs, const NdArray<dtype>& rhs)
    {
        STATIC_ASSERT_ARITHMETIC_OR_COMPLEX(dtype);
 
        return broadcast::broadcaster<dtype>(lhs, rhs, std::plus<dtype>());
    }
    NdArray<dtype> operator+(const NdArray<dtype>& lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<std::complex<dtype>> operator+(const NdArray<dtype>& lhs, const NdArray<std::complex<dtype>>& rhs)
    {
        STATIC_ASSERT_ARITHMETIC(dtype);
 
        const auto function = [](const auto& val1, const auto& val2) -> std::complex<dtype> { return val1 + val2; };
        return broadcast::broadcaster<std::complex<dtype>>(lhs, rhs, function);
    }
    NdArray<std::complex<dtype>> operator+(const NdArray<dtype>& lhs, const NdArray<std::complex<dtype>>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<std::complex<dtype>> operator+(const NdArray<std::complex<dtype>>& lhs, const NdArray<dtype>& rhs)
    {
        return rhs + lhs;
    }
    NdArray<std::complex<dtype>> operator+(const NdArray<std::complex<dtype>>& lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype> operator+(NdArray<dtype> lhs, dtype rhs)
    {
        lhs += rhs;
        return lhs;
    }
    NdArray<dtype> operator+(NdArray<dtype> lhs, dtype rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype> operator+(dtype lhs, const NdArray<dtype>& rhs)
    {
        return rhs + lhs;
    }
    NdArray<dtype> operator+(dtype lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<std::complex<dtype>> operator+(const NdArray<dtype>& lhs, const std::complex<dtype>& rhs)
    {
        STATIC_ASSERT_ARITHMETIC(dtype);
 
        const auto function = [rhs](dtype value) -> std::complex<dtype> { return value + rhs; };
 
        NdArray<std::complex<dtype>> returnArray(lhs.shape());
 
        stl_algorithms::transform(lhs.cbegin(), lhs.cend(), returnArray.begin(), function);
 
        return returnArray;
    }
    NdArray<std::complex<dtype>> operator+(const NdArray<dtype>& lhs, const std::complex<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<std::complex<dtype>> operator+(const std::complex<dtype>& lhs, const NdArray<dtype>& rhs)
    {
        return rhs + lhs;
    }
    NdArray<std::complex<dtype>> operator+(const std::complex<dtype>& lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<std::complex<dtype>> operator+(NdArray<std::complex<dtype>> lhs, dtype rhs)
    {
        lhs += rhs;
        return lhs;
    }
    NdArray<std::complex<dtype>> operator+(NdArray<std::complex<dtype>> lhs, dtype rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<std::complex<dtype>> operator+(dtype lhs, const NdArray<std::complex<dtype>>& rhs)
    {
        return rhs + lhs;
    }
    NdArray<std::complex<dtype>> operator+(dtype lhs, const NdArray<std::complex<dtype>>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype>& operator-=(NdArray<dtype>& lhs, const NdArray<dtype>& rhs)
    {
        STATIC_ASSERT_ARITHMETIC_OR_COMPLEX(dtype);
 
        return broadcast::broadcaster(lhs, rhs, std::minus<dtype>());
    }
    NdArray<dtype>& operator-=(NdArray<dtype>& lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<std::complex<dtype>>& operator-=(NdArray<std::complex<dtype>>& lhs, const NdArray<dtype>& rhs)
    {
        STATIC_ASSERT_ARITHMETIC(dtype);
 
        const auto function = [](const std::complex<dtype>& val1, dtype val2) -> std::complex<dtype>
        { return val1 - val2; };
        return broadcast::broadcaster(lhs, rhs, function);
    }
    NdArray<std::complex<dtype>>& operator-=(NdArray<std::complex<dtype>>& lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype>& operator-=(NdArray<dtype>& lhs, dtype rhs)
    {
        STATIC_ASSERT_ARITHMETIC_OR_COMPLEX(dtype);
 
        const auto function = [rhs](dtype& value) -> dtype { return value -= rhs; };
 
        stl_algorithms::for_each(lhs.begin(), lhs.end(), function);
 
        return lhs;
    }
    NdArray<dtype>& operator-=(NdArray<dtype>& lhs, dtype rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<std::complex<dtype>>& operator-=(NdArray<std::complex<dtype>>& lhs, dtype rhs)
    {
        STATIC_ASSERT_ARITHMETIC(dtype);
 
        const auto function = [rhs](std::complex<dtype>& value) -> std::complex<dtype> { return value -= rhs; };
 
        stl_algorithms::for_each(lhs.begin(), lhs.end(), function);
 
        return lhs;
    }
    NdArray<std::complex<dtype>>& operator-=(NdArray<std::complex<dtype>>& lhs, dtype rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype> operator-(const NdArray<dtype>& lhs, const NdArray<dtype>& rhs)
    {
        STATIC_ASSERT_ARITHMETIC_OR_COMPLEX(dtype);
 
        return broadcast::broadcaster<dtype>(lhs, rhs, std::minus<dtype>());
    }
    NdArray<dtype> operator-(const NdArray<dtype>& lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<std::complex<dtype>> operator-(const NdArray<dtype>& lhs, const NdArray<std::complex<dtype>>& rhs)
    {
        STATIC_ASSERT_ARITHMETIC(dtype);
 
        const auto function = [](const auto& val1, const auto& val2) -> std::complex<dtype> { return val1 - val2; };
        return broadcast::broadcaster<std::complex<dtype>>(lhs, rhs, function);
    }
    NdArray<std::complex<dtype>> operator-(const NdArray<dtype>& lhs, const NdArray<std::complex<dtype>>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<std::complex<dtype>> operator-(const NdArray<std::complex<dtype>>& lhs, const NdArray<dtype>& rhs)
    {
        STATIC_ASSERT_ARITHMETIC(dtype);
 
        const auto function = [](const auto& val1, const auto& val2) -> std::complex<dtype> { return val1 - val2; };
        return broadcast::broadcaster<std::complex<dtype>>(lhs, rhs, function);
    }
    NdArray<std::complex<dtype>> operator-(const NdArray<std::complex<dtype>>& lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype> operator-(NdArray<dtype> lhs, dtype rhs)
    {
        lhs -= rhs;
        return lhs;
    }
    NdArray<dtype> operator-(NdArray<dtype> lhs, dtype rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype> operator-(dtype lhs, const NdArray<dtype>& rhs)
    {
        STATIC_ASSERT_ARITHMETIC_OR_COMPLEX(dtype);
 
        const auto function = [lhs](dtype value) -> dtype { return lhs - value; };
 
        NdArray<dtype> returnArray(rhs.shape());
 
        stl_algorithms::transform(rhs.cbegin(), rhs.cend(), returnArray.begin(), function);
 
        return returnArray;
    }
    NdArray<dtype> operator-(dtype lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<std::complex<dtype>> operator-(const NdArray<dtype>& lhs, const std::complex<dtype>& rhs)
    {
        STATIC_ASSERT_ARITHMETIC(dtype);
 
        const auto function = [rhs](dtype value) -> std::complex<dtype> { return value - rhs; };
 
        NdArray<std::complex<dtype>> returnArray(lhs.shape());
 
        stl_algorithms::transform(lhs.cbegin(), lhs.cend(), returnArray.begin(), function);
 
        return returnArray;
    }
    NdArray<std::complex<dtype>> operator-(const NdArray<dtype>& lhs, const std::complex<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<std::complex<dtype>> operator-(const std::complex<dtype>& lhs, const NdArray<dtype>& rhs)
    {
        STATIC_ASSERT_ARITHMETIC(dtype);
 
        const auto function = [lhs](dtype value) -> std::complex<dtype> { return lhs - value; };
 
        NdArray<std::complex<dtype>> returnArray(rhs.shape());
 
        stl_algorithms::transform(rhs.cbegin(), rhs.cend(), returnArray.begin(), function);
 
        return returnArray;
    }
    NdArray<std::complex<dtype>> operator-(const std::complex<dtype>& lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<std::complex<dtype>> operator-(NdArray<std::complex<dtype>> lhs, dtype rhs)
    {
        lhs -= rhs;
        return lhs;
    }
    NdArray<std::complex<dtype>> operator-(NdArray<std::complex<dtype>> lhs, dtype rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<std::complex<dtype>> operator-(dtype lhs, const NdArray<std::complex<dtype>>& rhs)
    {
        STATIC_ASSERT_ARITHMETIC(dtype);
 
        const auto function = [lhs](std::complex<dtype> value) -> std::complex<dtype> { return lhs - value; };
 
        NdArray<std::complex<dtype>> returnArray(rhs.shape());
 
        stl_algorithms::transform(rhs.cbegin(), rhs.cend(), returnArray.begin(), function);
 
        return returnArray;
    }
    NdArray<std::complex<dtype>> operator-(dtype lhs, const NdArray<std::complex<dtype>>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype> operator-(const NdArray<dtype>& inArray)
    {
        const auto function = [](dtype value) -> dtype { return -value; };
 
        auto returnArray = NdArray<dtype>(inArray.shape());
        stl_algorithms::transform(inArray.cbegin(), inArray.cend(), returnArray.begin(), function);
        return returnArray;
    }
    NdArray<dtype> operator-(const NdArray<dtype>& inArray) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype>& operator*=(NdArray<dtype>& lhs, const NdArray<dtype>& rhs)
    {
        STATIC_ASSERT_ARITHMETIC_OR_COMPLEX(dtype);
 
        return broadcast::broadcaster(lhs, rhs, std::multiplies<dtype>());
    }
    NdArray<dtype>& operator*=(NdArray<dtype>& lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<std::complex<dtype>>& operator*=(NdArray<std::complex<dtype>>& lhs, const NdArray<dtype>& rhs)
    {
        STATIC_ASSERT_ARITHMETIC(dtype);
 
        const auto function = [](const std::complex<dtype>& val1, dtype val2) -> std::complex<dtype>
        { return val1 * val2; };
        return broadcast::broadcaster(lhs, rhs, function);
    }
    NdArray<std::complex<dtype>>& operator*=(NdArray<std::complex<dtype>>& lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype>& operator*=(NdArray<dtype>& lhs, dtype rhs)
    {
        STATIC_ASSERT_ARITHMETIC_OR_COMPLEX(dtype);
 
        const auto function = [rhs](dtype& value) -> dtype { return value *= rhs; };
 
        stl_algorithms::for_each(lhs.begin(), lhs.end(), function);
 
        return lhs;
    }
    NdArray<dtype>& operator*=(NdArray<dtype>& lhs, dtype rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<std::complex<dtype>>& operator*=(NdArray<std::complex<dtype>>& lhs, dtype rhs)
    {
        STATIC_ASSERT_ARITHMETIC(dtype);
 
        const auto function = [rhs](std::complex<dtype>& value) -> std::complex<dtype> { return value *= rhs; };
 
        stl_algorithms::for_each(lhs.begin(), lhs.end(), function);
 
        return lhs;
    }
    NdArray<std::complex<dtype>>& operator*=(NdArray<std::complex<dtype>>& lhs, dtype rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype> operator*(const NdArray<dtype>& lhs, const NdArray<dtype>& rhs)
    {
        STATIC_ASSERT_ARITHMETIC_OR_COMPLEX(dtype);
 
        return broadcast::broadcaster<dtype>(lhs, rhs, std::multiplies<dtype>());
    }
    NdArray<dtype> operator*(const NdArray<dtype>& lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<std::complex<dtype>> operator*(const NdArray<dtype>& lhs, const NdArray<std::complex<dtype>>& rhs)
    {
        STATIC_ASSERT_ARITHMETIC(dtype);
 
        const auto function = [](const auto& val1, const auto& val2) -> std::complex<dtype> { return val1 * val2; };
        return broadcast::broadcaster<std::complex<dtype>>(lhs, rhs, function);
    }
    NdArray<std::complex<dtype>> operator*(const NdArray<dtype>& lhs, const NdArray<std::complex<dtype>>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<std::complex<dtype>> operator*(const NdArray<std::complex<dtype>>& lhs, const NdArray<dtype>& rhs)
    {
        return rhs * lhs;
    }
    NdArray<std::complex<dtype>> operator*(const NdArray<std::complex<dtype>>& lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype> operator*(NdArray<dtype> lhs, dtype rhs)
    {
        lhs *= rhs;
        return lhs;
    }
    NdArray<dtype> operator*(NdArray<dtype> lhs, dtype rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype> operator*(dtype lhs, const NdArray<dtype>& rhs)
    {
        return rhs * lhs;
    }
    NdArray<dtype> operator*(dtype lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<std::complex<dtype>> operator*(const NdArray<dtype>& lhs, const std::complex<dtype>& rhs)
    {
        STATIC_ASSERT_ARITHMETIC(dtype);
 
        const auto function = [rhs](dtype value) -> std::complex<dtype> { return value * rhs; };
 
        NdArray<std::complex<dtype>> returnArray(lhs.shape());
 
        stl_algorithms::transform(lhs.cbegin(), lhs.cend(), returnArray.begin(), function);
 
        return returnArray;
    }
    NdArray<std::complex<dtype>> operator*(const NdArray<dtype>& lhs, const std::complex<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<std::complex<dtype>> operator*(const std::complex<dtype>& lhs, const NdArray<dtype>& rhs)
    {
        return rhs * lhs;
    }
    NdArray<std::complex<dtype>> operator*(const std::complex<dtype>& lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<std::complex<dtype>> operator*(NdArray<std::complex<dtype>> lhs, dtype rhs)
    {
        lhs *= rhs;
        return lhs;
    }
    NdArray<std::complex<dtype>> operator*(NdArray<std::complex<dtype>> lhs, dtype rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<std::complex<dtype>> operator*(dtype lhs, const NdArray<std::complex<dtype>>& rhs)
    {
        return rhs * lhs;
    }
    NdArray<std::complex<dtype>> operator*(dtype lhs, const NdArray<std::complex<dtype>>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype>& operator/=(NdArray<dtype>& lhs, const NdArray<dtype>& rhs)
    {
        STATIC_ASSERT_ARITHMETIC_OR_COMPLEX(dtype);
 
        return broadcast::broadcaster(lhs, rhs, std::divides<dtype>());
    }
    NdArray<dtype>& operator/=(NdArray<dtype>& lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<std::complex<dtype>>& operator/=(NdArray<std::complex<dtype>>& lhs, const NdArray<dtype>& rhs)
    {
        STATIC_ASSERT_ARITHMETIC(dtype);
 
        const auto function = [](const std::complex<dtype>& val1, dtype val2) -> std::complex<dtype>
        { return val1 / val2; };
        return broadcast::broadcaster(lhs, rhs, function);
    }
    NdArray<std::complex<dtype>>& operator/=(NdArray<std::complex<dtype>>& lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype>& operator/=(NdArray<dtype>& lhs, dtype rhs)
    {
        STATIC_ASSERT_ARITHMETIC_OR_COMPLEX(dtype);
 
        const auto function = [rhs](dtype& value) -> dtype { return value /= rhs; };
 
        stl_algorithms::for_each(lhs.begin(), lhs.end(), function);
 
        return lhs;
    }
    NdArray<dtype>& operator/=(NdArray<dtype>& lhs, dtype rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<std::complex<dtype>>& operator/=(NdArray<std::complex<dtype>>& lhs, dtype rhs)
    {
        STATIC_ASSERT_ARITHMETIC(dtype);
 
        const auto function = [rhs](std::complex<dtype>& value) -> std::complex<dtype> { return value /= rhs; };
 
        stl_algorithms::for_each(lhs.begin(), lhs.end(), function);
 
        return lhs;
    }
    NdArray<std::complex<dtype>>& operator/=(NdArray<std::complex<dtype>>& lhs, dtype rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype> operator/(const NdArray<dtype>& lhs, const NdArray<dtype>& rhs)
    {
        STATIC_ASSERT_ARITHMETIC_OR_COMPLEX(dtype);
 
        return broadcast::broadcaster<dtype>(lhs, rhs, std::divides<dtype>());
    }
    NdArray<dtype> operator/(const NdArray<dtype>& lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<std::complex<dtype>> operator/(const NdArray<dtype>& lhs, const NdArray<std::complex<dtype>>& rhs)
    {
        STATIC_ASSERT_ARITHMETIC(dtype);
 
        const auto function = [](const auto& val1, const auto& val2) -> std::complex<dtype> { return val1 / val2; };
        return broadcast::broadcaster<std::complex<dtype>>(lhs, rhs, function);
    }
    NdArray<std::complex<dtype>> operator/(const NdArray<dtype>& lhs, const NdArray<std::complex<dtype>>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<std::complex<dtype>> operator/(const NdArray<std::complex<dtype>>& lhs, const NdArray<dtype>& rhs)
    {
        STATIC_ASSERT_ARITHMETIC(dtype);
 
        const auto function = [](const auto& val1, const auto& val2) -> std::complex<dtype> { return val1 / val2; };
        return broadcast::broadcaster<std::complex<dtype>>(lhs, rhs, function);
    }
    NdArray<std::complex<dtype>> operator/(const NdArray<std::complex<dtype>>& lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype> operator/(NdArray<dtype> lhs, dtype rhs)
    {
        lhs /= rhs;
        return lhs;
    }
    NdArray<dtype> operator/(NdArray<dtype> lhs, dtype rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype> operator/(dtype lhs, const NdArray<dtype>& rhs)
    {
        STATIC_ASSERT_ARITHMETIC_OR_COMPLEX(dtype);
 
        const auto function = [lhs](dtype value) -> dtype { return lhs / value; };
 
        NdArray<dtype> returnArray(rhs.shape());
 
        stl_algorithms::transform(rhs.cbegin(), rhs.cend(), returnArray.begin(), function);
 
        return returnArray;
    }
    NdArray<dtype> operator/(dtype lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<std::complex<dtype>> operator/(const NdArray<dtype>& lhs, const std::complex<dtype>& rhs)
    {
        STATIC_ASSERT_ARITHMETIC(dtype);
 
        const auto function = [rhs](dtype value) -> std::complex<dtype> { return value / rhs; };
 
        NdArray<std::complex<dtype>> returnArray(lhs.shape());
 
        stl_algorithms::transform(lhs.cbegin(), lhs.cend(), returnArray.begin(), function);
 
        return returnArray;
    }
    NdArray<std::complex<dtype>> operator/(const NdArray<dtype>& lhs, const std::complex<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<std::complex<dtype>> operator/(const std::complex<dtype>& lhs, const NdArray<dtype>& rhs)
    {
        STATIC_ASSERT_ARITHMETIC(dtype);
 
        const auto function = [lhs](dtype value) -> std::complex<dtype> { return lhs / value; };
 
        NdArray<std::complex<dtype>> returnArray(rhs.shape());
 
        stl_algorithms::transform(rhs.cbegin(), rhs.cend(), returnArray.begin(), function);
 
        return returnArray;
    }
    NdArray<std::complex<dtype>> operator/(const std::complex<dtype>& lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<std::complex<dtype>> operator/(NdArray<std::complex<dtype>> lhs, dtype rhs)
    {
        lhs /= rhs;
        return lhs;
    }
    NdArray<std::complex<dtype>> operator/(NdArray<std::complex<dtype>> lhs, dtype rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<std::complex<dtype>> operator/(dtype lhs, const NdArray<std::complex<dtype>>& rhs)
    {
        STATIC_ASSERT_ARITHMETIC(dtype);
 
        const auto function = [lhs](const std::complex<dtype>& value) -> std::complex<dtype> { return lhs / value; };
 
        NdArray<std::complex<dtype>> returnArray(rhs.shape());
 
        stl_algorithms::transform(rhs.cbegin(), rhs.cend(), returnArray.begin(), function);
 
        return returnArray;
    }
    NdArray<std::complex<dtype>> operator/(dtype lhs, const NdArray<std::complex<dtype>>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype, std::enable_if_t<std::is_integral_v<dtype> || std::is_floating_point_v<dtype>, int> = 0>
    NdArray<dtype>& operator%=(NdArray<dtype>& lhs, const NdArray<dtype>& rhs)
    {
        if constexpr (std::is_integral_v<dtype>)
        {
            return broadcast::broadcaster(lhs, rhs, std::modulus<dtype>());
        }
        else
        {
            const auto function = [](const dtype value1, const dtype value2) -> dtype
            { return std::fmod(value1, value2); };
            return broadcast::broadcaster(lhs, rhs, function);
        }
    }
    NdArray<dtype>& operator%=(NdArray<dtype>& lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype, std::enable_if_t<std::is_integral_v<dtype> || std::is_floating_point_v<dtype>, int> = 0>
    NdArray<dtype>& operator%=(NdArray<dtype>& lhs, dtype rhs)
    {
        if constexpr (std::is_integral_v<dtype>)
        {
            const auto function = [rhs](dtype& value) -> dtype { return value %= rhs; };
            stl_algorithms::for_each(lhs.begin(), lhs.end(), function);
        }
        else
        {
            const auto function = [rhs](dtype& value) -> void { value = std::fmod(value, rhs); };
            stl_algorithms::for_each(lhs.begin(), lhs.end(), function);
        }
 
        return lhs;
    }
    NdArray<dtype>& operator%=(NdArray<dtype>& lhs, dtype rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype, std::enable_if_t<std::is_integral_v<dtype> || std::is_floating_point_v<dtype>, int> = 0>
    NdArray<dtype> operator%(const NdArray<dtype>& lhs, const NdArray<dtype>& rhs)
    {
        if constexpr (std::is_integral_v<dtype>)
        {
            return broadcast::broadcaster<dtype>(lhs, rhs, std::modulus<dtype>());
        }
        else
        {
            const auto function = [](dtype value1, dtype value2) -> dtype { return std::fmod(value1, value2); };
            return broadcast::broadcaster<dtype>(lhs, rhs, function);
        }
    }
    NdArray<dtype> operator%(const NdArray<dtype>& lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype> operator%(NdArray<dtype> lhs, dtype rhs)
    {
        lhs %= rhs;
        return lhs;
    }
    NdArray<dtype> operator%(NdArray<dtype> lhs, dtype rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype, std::enable_if_t<std::is_integral_v<dtype>, int> = 0>
    NdArray<dtype> operator%(dtype lhs, const NdArray<dtype>& rhs)
    {
        NdArray<dtype> returnArray(rhs.shape());
        stl_algorithms::transform(rhs.begin(),
                                  rhs.end(),
                                  returnArray.begin(),
                                  [lhs](dtype value) -> dtype { return lhs % value; });
 
        return returnArray;
    }
    NdArray<dtype> operator%(dtype lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype, std::enable_if_t<std::is_floating_point_v<dtype>, int> = 0>
    NdArray<dtype> operator%(dtype lhs, const NdArray<dtype>& rhs)
    {
        NdArray<dtype> returnArray(rhs.shape());
        stl_algorithms::transform(rhs.begin(),
                                  rhs.end(),
                                  returnArray.begin(),
                                  [lhs](dtype value) -> dtype { return std::fmod(lhs, value); });
 
        return returnArray;
    }
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype>& operator|=(NdArray<dtype>& lhs, const NdArray<dtype>& rhs)
    {
        STATIC_ASSERT_INTEGER(dtype);
 
        return broadcast::broadcaster(lhs, rhs, std::bit_or<dtype>());
    }
    NdArray<dtype>& operator|=(NdArray<dtype>& lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype>& operator|=(NdArray<dtype>& lhs, dtype rhs)
    {
        STATIC_ASSERT_INTEGER(dtype);
 
        const auto function = [rhs](dtype& value) -> dtype { return value |= rhs; };
 
        stl_algorithms::for_each(lhs.begin(), lhs.end(), function);
 
        return lhs;
    }
    NdArray<dtype>& operator|=(NdArray<dtype>& lhs, dtype rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype> operator|(const NdArray<dtype>& lhs, const NdArray<dtype>& rhs)
    {
        STATIC_ASSERT_INTEGER(dtype);
 
        return broadcast::broadcaster<dtype>(lhs, rhs, std::bit_or<dtype>());
    }
    NdArray<dtype> operator|(const NdArray<dtype>& lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype> operator|(NdArray<dtype> lhs, dtype rhs)
    {
        lhs |= rhs;
        return lhs;
    }
    NdArray<dtype> operator|(NdArray<dtype> lhs, dtype rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype> operator|(dtype lhs, const NdArray<dtype>& rhs)
    {
        return rhs | lhs;
    }
    NdArray<dtype> operator|(dtype lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype>& operator&=(NdArray<dtype>& lhs, const NdArray<dtype>& rhs)
    {
        STATIC_ASSERT_INTEGER(dtype);
 
        return broadcast::broadcaster(lhs, rhs, std::bit_and<dtype>());
    }
    NdArray<dtype>& operator&=(NdArray<dtype>& lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype>& operator&=(NdArray<dtype>& lhs, dtype rhs)
    {
        STATIC_ASSERT_INTEGER(dtype);
 
        const auto function = [rhs](dtype& value) -> dtype { return value &= rhs; };
 
        stl_algorithms::for_each(lhs.begin(), lhs.end(), function);
 
        return lhs;
    }
    NdArray<dtype>& operator&=(NdArray<dtype>& lhs, dtype rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype> operator&(const NdArray<dtype>& lhs, const NdArray<dtype>& rhs)
    {
        STATIC_ASSERT_INTEGER(dtype);
 
        return broadcast::broadcaster<dtype>(lhs, rhs, std::bit_and<dtype>());
    }
    NdArray<dtype> operator&(const NdArray<dtype>& lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype> operator&(NdArray<dtype> lhs, dtype rhs)
    {
        lhs &= rhs;
        return lhs;
    }
    NdArray<dtype> operator&(NdArray<dtype> lhs, dtype rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype> operator&(dtype lhs, const NdArray<dtype>& rhs)
    {
        return rhs & lhs;
    }
    NdArray<dtype> operator&(dtype lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype>& operator^=(NdArray<dtype>& lhs, const NdArray<dtype>& rhs)
    {
        STATIC_ASSERT_INTEGER(dtype);
 
        return broadcast::broadcaster(lhs, rhs, std::bit_xor<dtype>());
    }
    NdArray<dtype>& operator^=(NdArray<dtype>& lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype>& operator^=(NdArray<dtype>& lhs, dtype rhs)
    {
        STATIC_ASSERT_INTEGER(dtype);
 
        const auto function = [rhs](dtype& value) -> dtype { return value ^= rhs; };
 
        stl_algorithms::for_each(lhs.begin(), lhs.end(), function);
 
        return lhs;
    }
    NdArray<dtype>& operator^=(NdArray<dtype>& lhs, dtype rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype> operator^(const NdArray<dtype>& lhs, const NdArray<dtype>& rhs)
    {
        STATIC_ASSERT_INTEGER(dtype);
 
        return broadcast::broadcaster<dtype>(lhs, rhs, std::bit_xor<dtype>());
    }
    NdArray<dtype> operator^(const NdArray<dtype>& lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype> operator^(NdArray<dtype> lhs, dtype rhs)
    {
        lhs ^= rhs;
        return lhs;
    }
    NdArray<dtype> operator^(NdArray<dtype> lhs, dtype rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype> operator^(dtype lhs, const NdArray<dtype>& rhs)
    {
        return rhs ^ lhs;
    }
    NdArray<dtype> operator^(dtype lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype> operator~(const NdArray<dtype>& inArray)
    {
        STATIC_ASSERT_INTEGER(dtype);
 
        const auto function = [](dtype value) -> dtype { return ~value; };
 
        NdArray<dtype> returnArray(inArray.shape());
 
        stl_algorithms::transform(inArray.cbegin(), inArray.cend(), returnArray.begin(), function);
 
        return returnArray;
    }
    NdArray<dtype> operator~(const NdArray<dtype>& inArray) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<bool> operator&&(const NdArray<dtype>& lhs, const NdArray<dtype>& rhs)
    {
        STATIC_ASSERT_ARITHMETIC(dtype);
 
        const auto function = [](dtype value1, dtype value2) -> bool
        { return !utils::essentiallyEqual(value1, dtype{ 0 }) && !utils::essentiallyEqual(value2, dtype{ 0 }); };
 
        return broadcast::broadcaster<bool>(lhs, rhs, function);
    }
    NdArray<bool> operator&&(const NdArray<dtype>& lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<bool> operator&&(const NdArray<dtype>& lhs, dtype rhs)
    {
        STATIC_ASSERT_ARITHMETIC(dtype);
 
        NdArray<bool> returnArray(lhs.shape());
 
        const auto function = [rhs](dtype value) -> bool { return value && rhs; };
 
        stl_algorithms::transform(lhs.cbegin(), lhs.cend(), returnArray.begin(), function);
 
        return returnArray;
    }
    NdArray<bool> operator&&(const NdArray<dtype>& lhs, dtype rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<bool> operator&&(dtype lhs, const NdArray<dtype>& rhs)
    {
        return rhs && lhs;
    }
    NdArray<bool> operator&&(dtype lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<bool> operator||(const NdArray<dtype>& lhs, const NdArray<dtype>& rhs)
    {
        STATIC_ASSERT_ARITHMETIC(dtype);
 
        const auto function = [](dtype value1, dtype value2) -> bool
        { return !utils::essentiallyEqual(value1, dtype{ 0 }) || !utils::essentiallyEqual(value2, dtype{ 0 }); };
 
        return broadcast::broadcaster<bool>(lhs, rhs, function);
    }
    NdArray<bool> operator||(const NdArray<dtype>& lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<bool> operator||(const NdArray<dtype>& lhs, dtype rhs)
    {
        STATIC_ASSERT_ARITHMETIC(dtype);
 
        NdArray<bool> returnArray(lhs.shape());
 
        const auto function = [rhs](dtype value) -> bool { return value || rhs; };
 
        stl_algorithms::transform(lhs.cbegin(), lhs.cend(), returnArray.begin(), function);
 
        return returnArray;
    }
    NdArray<bool> operator||(const NdArray<dtype>& lhs, dtype rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<bool> operator||(dtype lhs, const NdArray<dtype>& rhs)
    {
        return rhs || lhs;
    }
    NdArray<bool> operator||(dtype lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<bool> operator!(const NdArray<dtype>& inArray)
    {
        STATIC_ASSERT_ARITHMETIC(dtype);
 
        NdArray<bool> returnArray(inArray.shape());
 
        const auto function = [](dtype value) -> dtype { return !value; };
 
        stl_algorithms::transform(inArray.cbegin(), inArray.cend(), returnArray.begin(), function);
 
        return returnArray;
    }
    NdArray<bool> operator!(const NdArray<dtype>& inArray) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<bool> operator==(const NdArray<dtype>& lhs, const NdArray<dtype>& rhs)
    {
        const auto equalTo = [](dtype lhs_, dtype rhs_) noexcept -> bool
        { return utils::essentiallyEqual(lhs_, rhs_); };
 
        return broadcast::broadcaster<bool>(lhs, rhs, equalTo);
    }
    NdArray<bool> operator==(const NdArray<dtype>& lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<bool> operator==(const NdArray<dtype>& lhs, dtype inValue)
    {
        NdArray<bool> returnArray(lhs.shape());
 
        const auto equalTo = [inValue](dtype value) noexcept -> bool
        { return utils::essentiallyEqual(inValue, value); };
 
        stl_algorithms::transform(lhs.cbegin(), lhs.cend(), returnArray.begin(), equalTo);
 
        return returnArray;
    }
    NdArray<bool> operator==(const NdArray<dtype>& lhs, dtype inValue) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<bool> operator==(dtype inValue, const NdArray<dtype>& inArray)
    {
        return inArray == inValue;
    }
    NdArray<bool> operator==(dtype inValue, const NdArray<dtype>& inArray) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<bool> operator!=(const NdArray<dtype>& lhs, const NdArray<dtype>& rhs)
    {
        const auto notEqualTo = [](dtype lhs_, dtype rhs_) noexcept -> bool
        { return !utils::essentiallyEqual(lhs_, rhs_); };
 
        return broadcast::broadcaster<bool>(lhs, rhs, notEqualTo);
    }
    NdArray<bool> operator!=(const NdArray<dtype>& lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<bool> operator!=(const NdArray<dtype>& lhs, dtype inValue)
    {
        NdArray<bool> returnArray(lhs.shape());
 
        const auto notEqualTo = [inValue](dtype value) noexcept -> bool
        { return !utils::essentiallyEqual(inValue, value); };
 
        stl_algorithms::transform(lhs.cbegin(), lhs.cend(), returnArray.begin(), notEqualTo);
 
        return returnArray;
    }
    NdArray<bool> operator!=(const NdArray<dtype>& lhs, dtype inValue) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<bool> operator!=(dtype inValue, const NdArray<dtype>& inArray)
    {
        return inArray != inValue;
    }
    NdArray<bool> operator!=(dtype inValue, const NdArray<dtype>& inArray) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<bool> operator<(const NdArray<dtype>& lhs, const NdArray<dtype>& rhs)
    {
        STATIC_ASSERT_ARITHMETIC_OR_COMPLEX(dtype);
 
        const auto function = [](dtype lhs_, dtype rhs_) noexcept -> bool { return lhs_ < rhs_; };
        return broadcast::broadcaster<bool>(lhs, rhs, function);
    }
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<bool> operator<(const NdArray<dtype>& lhs, dtype inValue)
    {
        STATIC_ASSERT_ARITHMETIC_OR_COMPLEX(dtype);
 
        NdArray<bool> returnArray(lhs.shape());
 
        const auto function = [inValue](dtype value) noexcept -> bool { return value < inValue; };
 
        stl_algorithms::transform(lhs.cbegin(), lhs.cend(), returnArray.begin(), function);
 
        return returnArray;
    }
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<bool> operator<(dtype inValue, const NdArray<dtype>& inArray)
    {
        STATIC_ASSERT_ARITHMETIC_OR_COMPLEX(dtype);
 
        NdArray<bool> returnArray(inArray.shape());
 
        const auto function = [inValue](dtype value) noexcept -> bool { return inValue < value; };
 
        stl_algorithms::transform(inArray.cbegin(), inArray.cend(), returnArray.begin(), function);
 
        return returnArray;
    }
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<bool> operator>(const NdArray<dtype>& lhs, const NdArray<dtype>& rhs)
    {
        STATIC_ASSERT_ARITHMETIC_OR_COMPLEX(dtype);
 
        const auto function = [](dtype lhs_, dtype rhs_) noexcept -> bool { return lhs_ > rhs_; };
        return broadcast::broadcaster<bool>(lhs, rhs, function);
    }
    NdArray<bool> operator>(const NdArray<dtype>& lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<bool> operator>(const NdArray<dtype>& lhs, dtype inValue)
    {
        STATIC_ASSERT_ARITHMETIC_OR_COMPLEX(dtype);
 
        NdArray<bool> returnArray(lhs.shape());
 
        const auto function = [inValue](dtype value) noexcept -> bool { return value > inValue; };
 
        stl_algorithms::transform(lhs.cbegin(), lhs.cend(), returnArray.begin(), function);
 
        return returnArray;
    }
    NdArray<bool> operator>(const NdArray<dtype>& lhs, dtype inValue) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<bool> operator>(dtype inValue, const NdArray<dtype>& inArray)
    {
        STATIC_ASSERT_ARITHMETIC_OR_COMPLEX(dtype);
 
        NdArray<bool> returnArray(inArray.shape());
 
        const auto function = [inValue](dtype value) noexcept -> bool { return inValue > value; };
 
        stl_algorithms::transform(inArray.cbegin(), inArray.cend(), returnArray.begin(), function);
 
        return returnArray;
    }
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<bool> operator<=(const NdArray<dtype>& lhs, const NdArray<dtype>& rhs)
    {
        STATIC_ASSERT_ARITHMETIC_OR_COMPLEX(dtype);
 
        const auto function = [](dtype lhs_, dtype rhs_) noexcept -> bool { return lhs_ <= rhs_; };
        return broadcast::broadcaster<bool>(lhs, rhs, function);
    }
    NdArray<bool> operator>(dtype inValue, const NdArray<dtype>& inArray) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<bool> operator<=(const NdArray<dtype>& lhs, dtype inValue)
    {
        STATIC_ASSERT_ARITHMETIC_OR_COMPLEX(dtype);
 
        NdArray<bool> returnArray(lhs.shape());
 
        const auto function = [inValue](dtype value) noexcept -> bool { return value <= inValue; };
 
        stl_algorithms::transform(lhs.cbegin(), lhs.cend(), returnArray.begin(), function);
 
        return returnArray;
    }
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<bool> operator<=(dtype inValue, const NdArray<dtype>& inArray)
    {
        STATIC_ASSERT_ARITHMETIC_OR_COMPLEX(dtype);
 
        NdArray<bool> returnArray(inArray.shape());
 
        const auto function = [inValue](dtype value) noexcept -> bool { return inValue <= value; };
 
        stl_algorithms::transform(inArray.cbegin(), inArray.cend(), returnArray.begin(), function);
 
        return returnArray;
    }
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<bool> operator>=(const NdArray<dtype>& lhs, const NdArray<dtype>& rhs)
    {
        STATIC_ASSERT_ARITHMETIC_OR_COMPLEX(dtype);
 
        const auto function = [](dtype lhs_, dtype rhs_) noexcept -> bool { return lhs_ >= rhs_; };
        return broadcast::broadcaster<bool>(lhs, rhs, function);
    }
    NdArray<bool> operator>=(const NdArray<dtype>& lhs, const NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<bool> operator>=(const NdArray<dtype>& lhs, dtype inValue)
    {
        STATIC_ASSERT_ARITHMETIC_OR_COMPLEX(dtype);
 
        NdArray<bool> returnArray(lhs.shape());
 
        const auto function = [inValue](dtype value) noexcept -> bool { return value >= inValue; };
 
        stl_algorithms::transform(lhs.cbegin(), lhs.cend(), returnArray.begin(), function);
 
        return returnArray;
    }
    NdArray<bool> operator>=(const NdArray<dtype>& lhs, dtype inValue) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<bool> operator>=(dtype inValue, const NdArray<dtype>& inArray)
    {
        STATIC_ASSERT_ARITHMETIC_OR_COMPLEX(dtype);
 
        NdArray<bool> returnArray(inArray.shape());
 
        const auto function = [inValue](dtype value) noexcept -> bool { return inValue >= value; };
 
        stl_algorithms::transform(inArray.cbegin(), inArray.cend(), returnArray.begin(), function);
 
        return returnArray;
    }
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype>& operator<<=(NdArray<dtype>& lhs, uint8 inNumBits)
    {
        STATIC_ASSERT_INTEGER(dtype);
 
        const auto function = [inNumBits](dtype& value) -> void { value <<= inNumBits; };
 
        stl_algorithms::for_each(lhs.begin(), lhs.end(), function);
 
        return lhs;
    }
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype> operator<<(const NdArray<dtype>& lhs, uint8 inNumBits)
    {
        STATIC_ASSERT_INTEGER(dtype);
 
        NdArray<dtype> returnArray(lhs);
        returnArray <<= inNumBits;
        return returnArray;
    }
    NdArray<bool> operator>=(dtype inValue, const NdArray<dtype>& inArray) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype>& operator>>=(NdArray<dtype>& lhs, uint8 inNumBits)
    {
        STATIC_ASSERT_INTEGER(dtype);
 
        const auto function = [inNumBits](dtype& value) -> void { value >>= inNumBits; };
 
        stl_algorithms::for_each(lhs.begin(), lhs.end(), function);
 
        return lhs;
    }
    NdArray<dtype>& operator>>=(NdArray<dtype>& lhs, uint8 inNumBits) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype> operator>>(const NdArray<dtype>& lhs, uint8 inNumBits)
    {
        STATIC_ASSERT_INTEGER(dtype);
 
        NdArray<dtype> returnArray(lhs);
        returnArray >>= inNumBits;
        return returnArray;
    }
    NdArray<dtype> operator>>(const NdArray<dtype>& lhs, uint8 inNumBits) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype>& operator++(NdArray<dtype>& rhs)
    {
        STATIC_ASSERT_ARITHMETIC(dtype);
 
        const auto function = [](dtype& value) -> void { ++value; };
 
        stl_algorithms::for_each(rhs.begin(), rhs.end(), function);
 
        return rhs;
    }
    NdArray<dtype>& operator++(NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype> operator++(NdArray<dtype>& lhs, int)
    {
        auto copy = NdArray<dtype>(lhs);
        ++lhs;
        return copy;
    }
    NdArray<dtype> operator++(NdArray<dtype>& lhs, int) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype>& operator--(NdArray<dtype>& rhs)
    {
        STATIC_ASSERT_ARITHMETIC(dtype);
 
        const auto function = [](dtype& value) -> void { --value; };
 
        stl_algorithms::for_each(rhs.begin(), rhs.end(), function);
 
        return rhs;
    }
    NdArray<dtype>& operator--(NdArray<dtype>& rhs) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype> operator--(NdArray<dtype>& lhs, int)
    {
        auto copy = NdArray<dtype>(lhs);
        --lhs;
        return copy;
    }
    NdArray<dtype> operator--(NdArray<dtype>& lhs, int) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    std::ostream& operator<<(std::ostream& inOStream, const NdArray<dtype>& inArray)
    {
        STATIC_ASSERT_ARITHMETIC_OR_COMPLEX(dtype);
 
        inOStream << inArray.str();
        return inOStream;
    }
    std::ostream& operator<<(std::ostream& inOStream, const NdArray<dtype>& inArray) {…}
} // namespace nc