complex_operator.hpp

Go to the documentation of this file.

#ifndef SJTXPMDBEYHNPQSGKFIEKTKOYWOFMOEGAHNOHMJVHJIAWTBHCCFUKCHLJMJAFPRHRXEOTYEDC
#define SJTXPMDBEYHNPQSGKFIEKTKOYWOFMOEGAHNOHMJVHJIAWTBHCCFUKCHLJMJAFPRHRXEOTYEDC
 
#include "./operation.hpp"
 
namespace ceras
{
 
    template< Expression Real_Ex, Expression Imag_Ex >
    struct complex
    {
        Real_Ex real_;
        Imag_Ex imag_;
    };//struct complex
 
 
    template< typename T >
    struct is_complex : std::false_type {};
 
    template< Expression Real_Ex, Expression Imag_Ex >
    struct is_complex<complex<Real_Ex, Imag_Ex>> : std::true_type {};
 
    template< typename T >
    constexpr bool is_complex_v = is_complex<T>::value;
 
    template< typename T >
    concept Complex = is_complex_v<T>;
 
 
    template< Expression Real_Ex, Expression Imag_Ex >
    Real_Ex real( complex<Real_Ex, Imag_Ex> const& c ) noexcept
    {
        return c.real_;
    }
 
    template< Expression Real_Ex, Expression Imag_Ex >
    Imag_Ex imag( complex<Real_Ex, Imag_Ex> const& c ) noexcept
    {
        return c.imag_;
    }
 
 
    template< Complex C >
    auto abs( C const& c ) noexcept
    {
        return hypot( real(c), imag(c) );
    }
 
 
    template< Complex C >
    auto norm( C const& c ) noexcept
    {
        auto const& r = real( c );
        auto const& i = imag( c );
        return hadamard_product( r, r ) + hadamard_product( i, i );
    }
 
 
    template< Complex C >
    auto conj( C const& c ) noexcept
    {
        return complex{ real(c), -imag(c) };
    }
 
 
    template< Expression Em, Expression Ep >
    auto polar( Em const& em, Ep const& ep ) noexcept
    {
        return complex{ hadamard_product( em, cos(ep) ), hadamard_product( em, sin(ep) ) };
    }
 
 
 
    template< Complex C >
    auto arg( C const& c ) noexcept
    {
        return atan2( imag(c), real(c) );
    }
 
 
    template< Complex C >
    auto operator + ( C const& c ) noexcept
    {
        return c;
    }
 
    template< Complex C >
    auto operator - ( C const& c ) noexcept
    {
        return complex{ negative(real(c)), negative(imag(c)) };
    }
 
 
    template< Complex Cl, Complex Cr >
    auto operator + ( Cl const& cl, Cr const& cr ) noexcept
    {
        return complex{ real(cl)+real(cr), imag(cl)+imag(cr) };
    }
 
 
    template< Complex Cl, Complex Cr >
    auto operator - ( Cl const& cl, Cr const& cr ) noexcept
    {
        return complex{ real(cl)-real(cr), imag(cl)-imag(cr) };
    }
 
 
    template< Complex Cl, Complex Cr >
    auto operator * ( Cl const& cl, Cr const& cr ) noexcept
    {
        auto const& a = real(cl);
        auto const& b = imag(cl);
        auto const& c = real(cr);
        auto const& d = imag(cr);
        auto const& ac = a * c;         // 1st multiplication
        auto const& bd = b * d;         // 2nd multiplication
        auto const& a_b = a + b;
        auto const& c_d = c + d;
        auto const& abcd = a_b * c_d;   // 3rd multiplication
 
        return complex{ ac-bd, abcd-ac-bd };
    }
 
 
 
    template< Complex C, Expression E >
    auto operator + ( C const& c, E const& e ) noexcept
    {
        return complex{ real(c)+e, imag(c) };
    }
 
    template< Complex C, Expression E >
    auto operator + ( E const& e, C const& c ) noexcept
    {
        return c + e;
    }
 
 
    template< Complex C, Expression E >
    auto operator - ( C const& c, E const& e ) noexcept
    {
        return complex{ real(c)-e, imag(c) };
    }
 
    template< Complex C, Expression E >
    auto operator - ( E const& e, C const& c ) noexcept
    {
        return c + e;
    }
 
    template< Complex C, Expression E >
    auto operator * ( C const& c, E const& e ) noexcept
    {
        return complex{ real(c)*e, imag(c)*e };
    }
 
    template< Complex C, Expression E >
    auto operator * ( E const& e, C const& c ) noexcept
    {
        return c * e;
    }
 
 
}//namespace ceras
 
#endif//SJTXPMDBEYHNPQSGKFIEKTKOYWOFMOEGAHNOHMJVHJIAWTBHCCFUKCHLJMJAFPRHRXEOTYEDC