dl_type_op.h

浏览该文件的文档.

#pragma once
 
#include <array>
#include <cstdint>
#include <vector>
 
namespace dl
{
//------------------------------N op N------------------------
template<typename T, std::size_t N>
constexpr Array<T, N>& operator+=(Array<T, N>& a, const Array<T, N>& b)
{
    for (std::size_t i = 0; i < N; ++i)
        a[i] += b[i];
    return a;
}
 
template<typename T, std::size_t N>
constexpr Array<T, N> operator+(const Array<T, N>& a, const Array<T, N>& b)
{
    Array<T, N> ret = a;
    return ret += b;
}
 
template<typename T, std::size_t N>
constexpr Array<T, N>& operator-=(Array<T, N>& a, const Array<T, N>& b)
{
    for (std::size_t i = 0; i < N; ++i)
        a[i] -= b[i];
    return a;
}
 
template<typename T, std::size_t N>
constexpr Array<T, N> operator-(const Array<T, N>& a, const Array<T, N>& b)
{
    Array<T, N> ret = a;
    return ret -= b;
}
 
template<typename T, std::size_t N>
constexpr Array<T, N>& operator*=(Array<T, N>& a, const Array<T, N>& b)
{
    for (std::size_t i = 0; i < N; ++i)
        a[i] *= b[i];
    return a;
}
 
template<typename T, std::size_t N>
constexpr Array<T, N> operator*(const Array<T, N>& a, const Array<T, N>& b)
{
    Array<T, N> ret = a;
    return ret *= b;
}
 
template<typename T, std::size_t N>
constexpr Array<T, N>& operator/=(Array<T, N>& a, const Array<T, N>& b)
{
    for (std::size_t i = 0; i < N; ++i)
        a[i] /= b[i];
    return a;
}
 
template<typename T, std::size_t N>
constexpr Array<T, N> operator/(const Array<T, N>& a, const Array<T, N>& b)
{
    Array<T, N> ret = a;
    return ret /= b;
}
 
//------------------------------N op 1------------------------
template<typename T, std::size_t N>
constexpr Array<T, N>& operator+=(Array<T, N>& a, const T& b)
{
    for (std::size_t i = 0; i < N; ++i)
        a[i] += b;
    return a;
}
 
template<typename T, std::size_t N>
constexpr Array<T, N> operator+(const Array<T, N>& a, const T& b)
{
    Array<T, N> ret = a;
    return ret += b;
}
 
template<typename T, std::size_t N>
constexpr Array<T, N>& operator-=(Array<T, N>& a, const T& b)
{
    for (std::size_t i = 0; i < N; ++i)
        a[i] -= b;
    return a;
}
 
template<typename T, std::size_t N>
constexpr Array<T, N> operator-(const Array<T, N>& a, const T& b)
{
    Array<T, N> ret = a;
    return ret -= b;
}
 
template<typename T, std::size_t N>
constexpr Array<T, N>& operator*=(Array<T, N>& a, const T& b)
{
    for (std::size_t i = 0; i < N; ++i)
        a[i] *= b;
    return a;
}
 
template<typename T, std::size_t N>
constexpr Array<T, N> operator*(const Array<T, N>& a, const T& b)
{
    Array<T, N> ret = a;
    return ret *= b;
}
 
template<typename T, std::size_t N>
constexpr Array<T, N>& operator/=(Array<T, N>& a, const T& b)
{
    for (std::size_t i = 0; i < N; ++i)
        a[i] /= b;
    return a;
}
 
template<typename T, std::size_t N>
constexpr Array<T, N> operator/(const Array<T, N>& a, const T& b)
{
    Array<T, N> ret = a;
    return ret /= b;
}
 
//------------------------------取负号------------------------
template<typename T, std::size_t N>
constexpr Array<T, N> operator-(const Array<T, N>& a)
{
    Array<T, N> ret = a;
    for (std::size_t i = 0; i < N; ++i)
        ret[i] = -ret[i];
    return ret;
}
 
template<typename T, std::size_t N>
constexpr Array<T, N> operator+(const Array<T, N>& a)
{
    Array<T, N> ret = a;
    for (std::size_t i = 0; i < N; ++i)
        ret[i] = +ret[i];
    return ret;
}
 
//------------------------------标准库容器扩展------------------------
template<typename T, std::size_t N>
std::vector<T>& operator+=(std::vector<T>& a, const std::array<T, N>& b)
{
    for (std::size_t i = 0; i < N; ++i)
        a.push_back(b[i]);
    return a;
}
 
}