complex.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSD-2-Clause
 
#ifndef pRC_CORE_COMPLEX_COMPLEX_H
#define pRC_CORE_COMPLEX_COMPLEX_H
 
#include <prc/core/basic/functions/identity.hpp>
#include <prc/core/basic/functions/unit.hpp>
#include <prc/core/basic/functions/zero.hpp>
#include <prc/core/functors/add.hpp>
#include <prc/core/functors/complexify.hpp>
#include <prc/core/functors/div.hpp>
#include <prc/core/functors/eval.hpp>
#include <prc/core/functors/mul.hpp>
#include <prc/core/functors/real.hpp>
#include <prc/core/functors/sub.hpp>
#include <prc/core/value/value.hpp>
 
namespace pRC
{
    template<IsValue T>
    class Complex
    {
    public:
        using Type = T;
        template<class C>
        using ChangeType = Complex<C>;
 
    public:
        ~Complex() = default;
        constexpr Complex(Complex const &) = default;
        constexpr Complex(Complex &&) = default;
        constexpr Complex &operator=(Complex const &) & = default;
        constexpr Complex &operator=(Complex &&) & = default;
        Complex() = default;
 
        template<IsConvertible<T> R>
        Complex(Complex<R> const &other)
            : mReal(other.real())
            , mImag(other.imag())
        {
        }
 
        template<IsConvertible<T> R>
        constexpr Complex(R const &real, R const &imag)
            : mReal(real)
            , mImag(imag)
        {
        }
 
        template<IsConvertible<T> R>
        Complex(R const &real)
            : mReal(real)
            , mImag(zero())
        {
        }
 
        constexpr Complex(Zero<> const)
            : Complex(zero<Complex>())
        {
        }
 
        constexpr Complex(Unit<> const)
            : Complex(unit<Complex>())
        {
        }
 
        constexpr Complex(Identity<> const)
            : Complex(identity<Complex>())
        {
        }
 
        template<IsConvertible<T> R>
        constexpr auto &operator=(Complex<R> const &rhs) &
        {
            mReal = rhs.real();
            mImag = rhs.imag();
            return *this;
        }
 
        template<IsConvertible<T> R>
        constexpr auto &operator=(R const &real) &
        {
            mReal = real;
            mImag = zero();
            return *this;
        }
 
        constexpr auto &operator=(Zero<> const) &
        {
            return *this = zero<Complex>();
        }
 
        constexpr auto &operator=(Unit<> const) &
        {
            return *this = unit<Complex>();
        }
 
        constexpr auto &operator=(Identity<> const) &
        {
            return *this = identity<Complex>();
        }
 
        constexpr decltype(auto) real() &&
        {
            return move(mReal);
        }
 
        constexpr decltype(auto) real() const &&
        {
            return move(mReal);
        }
 
        constexpr auto &real() &
        {
            return mReal;
        }
 
        constexpr auto &real() const &
        {
            return mReal;
        }
 
        constexpr decltype(auto) imag() &&
        {
            return move(mImag);
        }
 
        constexpr decltype(auto) imag() const &&
        {
            return move(mImag);
        }
 
        constexpr auto &imag() &
        {
            return mImag;
        }
 
        constexpr auto &imag() const &
        {
            return mImag;
        }
 
        template<class X>
            requires IsInvocable<Add, Complex &, X>
        constexpr auto &operator+=(X &&rhs) &
        {
            return *this = *this + forward<X>(rhs);
        }
 
        template<class X>
            requires IsInvocable<Sub, Complex &, X>
        constexpr auto &operator-=(X &&rhs) &
        {
            return *this = *this - forward<X>(rhs);
        }
 
        template<class X>
            requires IsInvocable<Mul, Complex &, X>
        constexpr auto &operator*=(X &&rhs) &
        {
            return *this = *this * forward<X>(rhs);
        }
 
        template<class X>
            requires IsInvocable<Div, Complex &, X>
        constexpr auto &operator/=(X &&rhs) &
        {
            return *this = *this / forward<X>(rhs);
        }
 
        constexpr operator T() const
        {
            return real();
        }
 
    private:
        T mReal;
        T mImag;
    };
 
    template<IsFloat T>
    Complex(T const &) -> Complex<T>;
 
    template<IsFloat R, IsFloat I>
    Complex(R const &, I const &) -> Complex<Common<R, I>>;
 
    template<class T>
    concept IsComplex = !IsReference<T> && requires {
        {
            []<class U>(Complex<U> const &&)
            {
            }(std::declval<T>())
        };
    };
 
    template<class T>
    concept IsComplexified =
        IsSame<ResultOf<Eval, T>, ResultOf<Eval, ResultOf<Complexify, T>>>;
 
    template<class T>
    using NonComplex = RemoveConstReference<ResultOf<Eval, ResultOf<Real, T>>>;
}
#endif // pRC_CORE_COMPLEX_COMPLEX_H