Complex functions¶

`c32` typedef¶

c32 = complex<f32>

Alias for complex

Source code

using c32 = complex<f32>

https://github.com/kfrlib/kfr/blob//include/kfr/simd/complex.hpp#L194

`c64` typedef¶

c64 = complex<f64>

Alias for complex

Source code

using c64 = complex<f64>

https://github.com/kfrlib/kfr/blob//include/kfr/simd/complex.hpp#L197

`cabs` function¶

template <typename T1, KFR_ENABLE_IF(is_numeric<T1>)>
realtype<T1> cabs(const T1 &x)

Returns the absolute value (magnitude) of the complex number x

Source code

template <typename T1, KFR_ENABLE_IF(is_numeric<T1>)>
KFR_FUNCTION realtype<T1> cabs(const T1& x)
{
    return intrinsics::cabs(x);
}

https://github.com/kfrlib/kfr/blob//include/kfr/math/complex_math.hpp#L292

template <typename E1,
          KFR_ENABLE_IF(is_input_expression<E1>)>
internal::expression_function<fn::cabs, E1> cabs(E1 &&x)

Returns template expression that returns the absolute value (magnitude) of the complex number x

Source code

template <typename E1, KFR_ENABLE_IF(is_input_expression<E1>)>
KFR_FUNCTION internal::expression_function<fn::cabs, E1> cabs(E1&& x)
{
    return { fn::cabs(), std::forward<E1>(x) };
}

https://github.com/kfrlib/kfr/blob//include/kfr/math/complex_math.hpp#L299

`cabssqr` function¶

template <typename T1, KFR_ENABLE_IF(is_numeric<T1>)>
realtype<T1> cabssqr(const T1 &x)

Returns the squared absolute value (magnitude squared) of the complex number x

Source code

template <typename T1, KFR_ENABLE_IF(is_numeric<T1>)>
KFR_FUNCTION realtype<T1> cabssqr(const T1& x)
{
    return intrinsics::cabssqr(x);
}

https://github.com/kfrlib/kfr/blob//include/kfr/math/complex_math.hpp#L277

template <typename E1,
          KFR_ENABLE_IF(is_input_expression<E1>)>
internal::expression_function<fn::cabssqr, E1>
cabssqr(E1 &&x)

Returns template expression that returns the squared absolute value (magnitude squared) of the complex number x

Source code

template <typename E1, KFR_ENABLE_IF(is_input_expression<E1>)>
KFR_FUNCTION internal::expression_function<fn::cabssqr, E1> cabssqr(E1&& x)
{
    return { fn::cabssqr(), std::forward<E1>(x) };
}

https://github.com/kfrlib/kfr/blob//include/kfr/math/complex_math.hpp#L285

`carg` function¶

template <typename T1, KFR_ENABLE_IF(is_numeric<T1>)>
realtype<T1> carg(const T1 &x)

Returns the phase angle (argument) of the complex number x

Source code

template <typename T1, KFR_ENABLE_IF(is_numeric<T1>)>
KFR_FUNCTION realtype<T1> carg(const T1& x)
{
    return intrinsics::carg(x);
}

https://github.com/kfrlib/kfr/blob//include/kfr/math/complex_math.hpp#L306

template <typename E1,
          KFR_ENABLE_IF(is_input_expression<E1>)>
internal::expression_function<fn::carg, E1> carg(E1 &&x)

Returns template expression that returns the phase angle (argument) of the complex number x

Source code

template <typename E1, KFR_ENABLE_IF(is_input_expression<E1>)>
KFR_FUNCTION internal::expression_function<fn::carg, E1> carg(E1&& x)
{
    return { fn::carg(), std::forward<E1>(x) };
}

https://github.com/kfrlib/kfr/blob//include/kfr/math/complex_math.hpp#L313

`cartesian` function¶

template <typename T1, KFR_ENABLE_IF(is_numeric<T1>)>
T1 cartesian(const T1 &x)

Converts complex number to cartesian

Source code

template <typename T1, KFR_ENABLE_IF(is_numeric<T1>)>
KFR_FUNCTION T1 cartesian(const T1& x)
{
    return intrinsics::cartesian(x);
}

https://github.com/kfrlib/kfr/blob//include/kfr/math/complex_math.hpp#L418

template <typename E1,
          KFR_ENABLE_IF(is_input_expression<E1>)>
internal::expression_function<fn::cartesian, E1>
cartesian(E1 &&x)

Returns template expression that converts complex number to cartesian

Source code

template <typename E1, KFR_ENABLE_IF(is_input_expression<E1>)>
KFR_FUNCTION internal::expression_function<fn::cartesian, E1> cartesian(E1&& x)
{
    return { fn::cartesian(), std::forward<E1>(x) };
}

https://github.com/kfrlib/kfr/blob//include/kfr/math/complex_math.hpp#L425

`cbase` typedef¶

cbase = complex<fbase>

Alias for complex

Source code

using cbase = complex<fbase>

https://github.com/kfrlib/kfr/blob//include/kfr/simd/complex.hpp#L200

`cconj` function¶

template <typename T1, KFR_ENABLE_IF(is_numeric<T1>)>
T1 cconj(const T1 &x)

Returns the complex conjugate of the complex number x

Source code

template <typename T1, KFR_ENABLE_IF(is_numeric<T1>)>
KFR_INTRINSIC T1 cconj(const T1& x)
{
    return intrinsics::cconj(x);
}

https://github.com/kfrlib/kfr/blob//include/kfr/simd/complex.hpp#L452

template <typename E1,
          KFR_ENABLE_IF(is_input_expression<E1>)>
internal::expression_function<fn::cconj, E1> cconj(E1 &&x)

Returns template expression that returns the complex conjugate of the complex number x

Source code

template <typename E1, KFR_ENABLE_IF(is_input_expression<E1>)>
KFR_FUNCTION internal::expression_function<fn::cconj, E1> cconj(E1&& x)
{
    return { fn::cconj(), std::forward<E1>(x) };
}

https://github.com/kfrlib/kfr/blob//include/kfr/simd/complex.hpp#L459

`ccos` function¶

template <typename T1, KFR_ENABLE_IF(is_numeric<T1>)>
T1 ccos(const T1 &x)

Returns the cosine of the complex number x

Source code

template <typename T1, KFR_ENABLE_IF(is_numeric<T1>)>
KFR_FUNCTION T1 ccos(const T1& x)
{
    return intrinsics::ccos(x);
}

https://github.com/kfrlib/kfr/blob//include/kfr/math/complex_math.hpp#L249

template <typename E1,
          KFR_ENABLE_IF(is_input_expression<E1>)>
internal::expression_function<fn::ccos, E1> ccos(E1 &&x)

Returns template expression that returns the cosine of the the complex value x

Source code

template <typename E1, KFR_ENABLE_IF(is_input_expression<E1>)>
KFR_FUNCTION internal::expression_function<fn::ccos, E1> ccos(E1&& x)
{
    return { fn::ccos(), std::forward<E1>(x) };
}

https://github.com/kfrlib/kfr/blob//include/kfr/math/complex_math.hpp#L256

`ccosh` function¶

template <typename T1, KFR_ENABLE_IF(is_numeric<T1>)>
T1 ccosh(const T1 &x)

Returns the hyperbolic cosine of the complex number x

Source code

template <typename T1, KFR_ENABLE_IF(is_numeric<T1>)>
KFR_FUNCTION T1 ccosh(const T1& x)
{
    return intrinsics::ccosh(x);
}

https://github.com/kfrlib/kfr/blob//include/kfr/math/complex_math.hpp#L263

template <typename E1,
          KFR_ENABLE_IF(is_input_expression<E1>)>
internal::expression_function<fn::ccosh, E1> ccosh(E1 &&x)

Returns template expression that returns the hyperbolic cosine of the the complex value x

Source code

template <typename E1, KFR_ENABLE_IF(is_input_expression<E1>)>
KFR_FUNCTION internal::expression_function<fn::ccosh, E1> ccosh(E1&& x)
{
    return { fn::ccosh(), std::forward<E1>(x) };
}

https://github.com/kfrlib/kfr/blob//include/kfr/math/complex_math.hpp#L270

`cdupimag` function¶

template <typename T, size_t N>
vec<complex<T>, N> cdupimag(const vec<complex<T>, N> &x)

Returns vector of complex values with imaginary part duplicated

Source code

template <typename T, size_t N>
KFR_INTRINSIC vec<complex<T>, N> cdupimag(const vec<complex<T>, N>& x)
{
    return ccomp(dupodd(cdecom(x)));
}

https://github.com/kfrlib/kfr/blob//include/kfr/simd/complex.hpp#L281

`cdupreal` function¶

template <typename T, size_t N>
vec<complex<T>, N> cdupreal(const vec<complex<T>, N> &x)

Returns vector of complex values with real part duplicated

Source code

template <typename T, size_t N>
KFR_INTRINSIC vec<complex<T>, N> cdupreal(const vec<complex<T>, N>& x)
{
    return ccomp(dupeven(cdecom(x)));
}

https://github.com/kfrlib/kfr/blob//include/kfr/simd/complex.hpp#L273

`cexp` function¶

template <typename T1, KFR_ENABLE_IF(is_numeric<T1>)>
T1 cexp(const T1 &x)

Returns \(e\) raised to the complex number x

Source code

template <typename T1, KFR_ENABLE_IF(is_numeric<T1>)>
KFR_FUNCTION T1 cexp(const T1& x)
{
    return intrinsics::cexp(x);
}

https://github.com/kfrlib/kfr/blob//include/kfr/math/complex_math.hpp#L362

template <typename E1,
          KFR_ENABLE_IF(is_input_expression<E1>)>
internal::expression_function<fn::cexp, E1> cexp(E1 &&x)

Returns template expression that returns \(e\) raised to the complex number x

Source code

template <typename E1, KFR_ENABLE_IF(is_input_expression<E1>)>
KFR_FUNCTION internal::expression_function<fn::cexp, E1> cexp(E1&& x)
{
    return { fn::cexp(), std::forward<E1>(x) };
}

https://github.com/kfrlib/kfr/blob//include/kfr/math/complex_math.hpp#L369

`cexp10` function¶

template <typename T1, KFR_ENABLE_IF(is_numeric<T1>)>
T1 cexp10(const T1 &x)

Returns 10 raised to the complex number x

Source code

template <typename T1, KFR_ENABLE_IF(is_numeric<T1>)>
KFR_FUNCTION T1 cexp10(const T1& x)
{
    return intrinsics::cexp10(x);
}

https://github.com/kfrlib/kfr/blob//include/kfr/math/complex_math.hpp#L390

template <typename E1,
          KFR_ENABLE_IF(is_input_expression<E1>)>
internal::expression_function<fn::cexp10, E1> cexp10(E1 &&x)

Returns template expression that returns 10 raised to the complex number x

Source code

template <typename E1, KFR_ENABLE_IF(is_input_expression<E1>)>
KFR_FUNCTION internal::expression_function<fn::cexp10, E1> cexp10(E1&& x)
{
    return { fn::cexp10(), std::forward<E1>(x) };
}

https://github.com/kfrlib/kfr/blob//include/kfr/math/complex_math.hpp#L397

`cexp2` function¶

template <typename T1, KFR_ENABLE_IF(is_numeric<T1>)>
T1 cexp2(const T1 &x)

Returns 2 raised to the complex number x

Source code

template <typename T1, KFR_ENABLE_IF(is_numeric<T1>)>
KFR_FUNCTION T1 cexp2(const T1& x)
{
    return intrinsics::cexp2(x);
}

https://github.com/kfrlib/kfr/blob//include/kfr/math/complex_math.hpp#L376

template <typename E1,
          KFR_ENABLE_IF(is_input_expression<E1>)>
internal::expression_function<fn::cexp2, E1> cexp2(E1 &&x)

Returns template expression that returns 2 raised to the complex number x

Source code

template <typename E1, KFR_ENABLE_IF(is_input_expression<E1>)>
KFR_FUNCTION internal::expression_function<fn::cexp2, E1> cexp2(E1&& x)
{
    return { fn::cexp2(), std::forward<E1>(x) };
}

https://github.com/kfrlib/kfr/blob//include/kfr/math/complex_math.hpp#L383

`clog` function¶

template <typename T1, KFR_ENABLE_IF(is_numeric<T1>)>
T1 clog(const T1 &x)

Returns the natural logarithm of the complex number x

Source code

template <typename T1, KFR_ENABLE_IF(is_numeric<T1>)>
KFR_FUNCTION T1 clog(const T1& x)
{
    return intrinsics::clog(x);
}

https://github.com/kfrlib/kfr/blob//include/kfr/math/complex_math.hpp#L320

template <typename E1,
          KFR_ENABLE_IF(is_input_expression<E1>)>
internal::expression_function<fn::clog, E1> clog(E1 &&x)

Returns template expression that returns the natural logarithm of the complex number x

Source code

template <typename E1, KFR_ENABLE_IF(is_input_expression<E1>)>
KFR_FUNCTION internal::expression_function<fn::clog, E1> clog(E1&& x)
{
    return { fn::clog(), std::forward<E1>(x) };
}

https://github.com/kfrlib/kfr/blob//include/kfr/math/complex_math.hpp#L327

`clog10` function¶

template <typename T1, KFR_ENABLE_IF(is_numeric<T1>)>
T1 clog10(const T1 &x)

Returns the common (base-10) logarithm of the complex number x

Source code

template <typename T1, KFR_ENABLE_IF(is_numeric<T1>)>
KFR_FUNCTION T1 clog10(const T1& x)
{
    return intrinsics::clog10(x);
}

https://github.com/kfrlib/kfr/blob//include/kfr/math/complex_math.hpp#L348

template <typename E1,
          KFR_ENABLE_IF(is_input_expression<E1>)>
internal::expression_function<fn::clog10, E1> clog10(E1 &&x)

Returns template expression that returns the common (base-10) logarithm of the complex number x

Source code

template <typename E1, KFR_ENABLE_IF(is_input_expression<E1>)>
KFR_FUNCTION internal::expression_function<fn::clog10, E1> clog10(E1&& x)
{
    return { fn::clog10(), std::forward<E1>(x) };
}

https://github.com/kfrlib/kfr/blob//include/kfr/math/complex_math.hpp#L355

`clog2` function¶

template <typename T1, KFR_ENABLE_IF(is_numeric<T1>)>
T1 clog2(const T1 &x)

Returns the binary (base-2) logarithm of the complex number x

Source code

template <typename T1, KFR_ENABLE_IF(is_numeric<T1>)>
KFR_FUNCTION T1 clog2(const T1& x)
{
    return intrinsics::clog2(x);
}

https://github.com/kfrlib/kfr/blob//include/kfr/math/complex_math.hpp#L334

template <typename E1,
          KFR_ENABLE_IF(is_input_expression<E1>)>
internal::expression_function<fn::clog2, E1> clog2(E1 &&x)

Returns template expression that returns the binary (base-2) logarithm of the complex number x

Source code

template <typename E1, KFR_ENABLE_IF(is_input_expression<E1>)>
KFR_FUNCTION internal::expression_function<fn::clog2, E1> clog2(E1&& x)
{
    return { fn::clog2(), std::forward<E1>(x) };
}

https://github.com/kfrlib/kfr/blob//include/kfr/math/complex_math.hpp#L341

`cnegimag` function¶

template <typename T, size_t N>
vec<complex<T>, N> cnegimag(const vec<complex<T>, N> &x)

Returns vector of complex values with imaginary part negated

Source code

template <typename T, size_t N>
KFR_INTRINSIC vec<complex<T>, N> cnegimag(const vec<complex<T>, N>& x)
{
    return x ^ complex<T>(T(), -T());
}

https://github.com/kfrlib/kfr/blob//include/kfr/simd/complex.hpp#L305

`cnegreal` function¶

template <typename T, size_t N>
vec<complex<T>, N> cnegreal(const vec<complex<T>, N> &x)

Returns vector of complex values with real part negated

Source code

template <typename T, size_t N>
KFR_INTRINSIC vec<complex<T>, N> cnegreal(const vec<complex<T>, N>& x)
{
    return x ^ complex<T>(-T(), T());
}

https://github.com/kfrlib/kfr/blob//include/kfr/simd/complex.hpp#L297

complex

`complex` class¶

template <typename T> complex

Represents the complex numbers. If KFR_STD_COMPLEX is defined, then kfr::complex is an alias for std::complex.

Source code

template <typename T>
struct complex
{
    static_assert(is_simd_type<T>, "Incorrect type for complex");
    constexpr static bool is_pod     = true;
    constexpr complex() CMT_NOEXCEPT = default;
    KFR_MEM_INTRINSIC constexpr complex(T re) CMT_NOEXCEPT : re(re), im(0) {}
    KFR_MEM_INTRINSIC constexpr complex(T re, T im) CMT_NOEXCEPT : re(re), im(im) {}
    constexpr complex(const complex&) CMT_NOEXCEPT = default;
    constexpr complex(complex&&) CMT_NOEXCEPT      = default;
    template <typename U>
    KFR_MEM_INTRINSIC constexpr complex(const complex<U>& other) CMT_NOEXCEPT : re(static_cast<T>(other.real())),
                                                                                im(static_cast<T>(other.imag()))
    {
    }
    template <typename U>
    KFR_MEM_INTRINSIC constexpr complex(complex<U>&& other) CMT_NOEXCEPT : re(std::move(other.real())),
                                                                           im(std::move(other.imag()))
    {
    }
#ifdef CMT_COMPILER_GNU
    constexpr complex& operator=(const complex&) CMT_NOEXCEPT = default;
    constexpr complex& operator=(complex&&) CMT_NOEXCEPT = default;
#else
    complex& operator=(const complex&) = default;
    complex& operator=(complex&&) = default;
#endif
    KFR_MEM_INTRINSIC constexpr const T& real() const CMT_NOEXCEPT { return re; }
    KFR_MEM_INTRINSIC constexpr const T& imag() const CMT_NOEXCEPT { return im; }
    KFR_MEM_INTRINSIC constexpr void real(T value) CMT_NOEXCEPT { re = value; }
    KFR_MEM_INTRINSIC constexpr void imag(T value) CMT_NOEXCEPT { im = value; }
private:
    T re;
    T im;
}

https://github.com/kfrlib/kfr/blob//include/kfr/simd/complex.hpp#L53

`csin` function¶

template <typename T1, KFR_ENABLE_IF(is_numeric<T1>)>
T1 csin(const T1 &x)

Returns the sine of the complex number x

Source code

template <typename T1, KFR_ENABLE_IF(is_numeric<T1>)>
KFR_FUNCTION T1 csin(const T1& x)
{
    return intrinsics::csin(x);
}

https://github.com/kfrlib/kfr/blob//include/kfr/math/complex_math.hpp#L221

template <typename E1,
          KFR_ENABLE_IF(is_input_expression<E1>)>
internal::expression_function<fn::csin, E1> csin(E1 &&x)

Returns template expression that returns the sine of the the complex value x

Source code

template <typename E1, KFR_ENABLE_IF(is_input_expression<E1>)>
KFR_FUNCTION internal::expression_function<fn::csin, E1> csin(E1&& x)
{
    return { fn::csin(), std::forward<E1>(x) };
}

https://github.com/kfrlib/kfr/blob//include/kfr/math/complex_math.hpp#L228

`csinh` function¶

template <typename T1, KFR_ENABLE_IF(is_numeric<T1>)>
T1 csinh(const T1 &x)

Returns the hyperbolic sine of the complex number x

Source code

template <typename T1, KFR_ENABLE_IF(is_numeric<T1>)>
KFR_FUNCTION T1 csinh(const T1& x)
{
    return intrinsics::csinh(x);
}

https://github.com/kfrlib/kfr/blob//include/kfr/math/complex_math.hpp#L235

template <typename E1,
          KFR_ENABLE_IF(is_input_expression<E1>)>
internal::expression_function<fn::csinh, E1> csinh(E1 &&x)

Returns template expression that returns the hyperbolic sine of the complex number x

Source code

template <typename E1, KFR_ENABLE_IF(is_input_expression<E1>)>
KFR_FUNCTION internal::expression_function<fn::csinh, E1> csinh(E1&& x)
{
    return { fn::csinh(), std::forward<E1>(x) };
}

https://github.com/kfrlib/kfr/blob//include/kfr/math/complex_math.hpp#L242

`csqr` function¶

template <typename T1, KFR_ENABLE_IF(is_numeric<T1>)>
T1 csqr(const T1 &x)

Returns square of the complex number x

Source code

template <typename T1, KFR_ENABLE_IF(is_numeric<T1>)>
KFR_FUNCTION T1 csqr(const T1& x)
{
    return intrinsics::csqr(x);
}

https://github.com/kfrlib/kfr/blob//include/kfr/math/complex_math.hpp#L446

template <typename E1,
          KFR_ENABLE_IF(is_input_expression<E1>)>
internal::expression_function<fn::csqr, E1> csqr(E1 &&x)

Returns template expression that returns square of the complex number x

Source code

template <typename E1, KFR_ENABLE_IF(is_input_expression<E1>)>
KFR_FUNCTION internal::expression_function<fn::csqr, E1> csqr(E1&& x)
{
    return { fn::csqr(), std::forward<E1>(x) };
}

https://github.com/kfrlib/kfr/blob//include/kfr/math/complex_math.hpp#L453

`csqrt` function¶

template <typename T1, KFR_ENABLE_IF(is_numeric<T1>)>
T1 csqrt(const T1 &x)

Returns square root of the complex number x

Source code

template <typename T1, KFR_ENABLE_IF(is_numeric<T1>)>
KFR_FUNCTION T1 csqrt(const T1& x)
{
    return intrinsics::csqrt(x);
}

https://github.com/kfrlib/kfr/blob//include/kfr/math/complex_math.hpp#L432

template <typename E1,
          KFR_ENABLE_IF(is_input_expression<E1>)>
internal::expression_function<fn::csqrt, E1> csqrt(E1 &&x)

Returns template expression that returns square root of the complex number x

Source code

template <typename E1, KFR_ENABLE_IF(is_input_expression<E1>)>
KFR_FUNCTION internal::expression_function<fn::csqrt, E1> csqrt(E1&& x)
{
    return { fn::csqrt(), std::forward<E1>(x) };
}

https://github.com/kfrlib/kfr/blob//include/kfr/math/complex_math.hpp#L439

`cswapreim` function¶

template <typename T, size_t N>
vec<complex<T>, N> cswapreim(const vec<complex<T>, N> &x)

Returns vector of complex values with real and imaginary parts swapped

Source code

template <typename T, size_t N>
KFR_INTRINSIC vec<complex<T>, N> cswapreim(const vec<complex<T>, N>& x)
{
    return ccomp(swap<2>(cdecom(x)));
}

https://github.com/kfrlib/kfr/blob//include/kfr/simd/complex.hpp#L289

`imag` function¶

template <typename T>
constexpr T imag(const complex<T> &value)

Returns the imaginary part of the complex value

Source code

template <typename T>
constexpr KFR_INTRINSIC T imag(const complex<T>& value)
{
    return value.imag();
}

https://github.com/kfrlib/kfr/blob//include/kfr/simd/complex.hpp#L394

template <typename T, size_t N>
constexpr vec<T, N> imag(const vec<complex<T>, N> &value)

Returns the imaginary part of the complex value

Source code

template <typename T, size_t N>
constexpr KFR_INTRINSIC vec<T, N> imag(const vec<complex<T>, N>& value)
{
    return odd(cdecom(value));
}

https://github.com/kfrlib/kfr/blob//include/kfr/simd/complex.hpp#L401

template <typename E1,
          KFR_ENABLE_IF(is_input_expression<E1>)>
internal::expression_function<fn::imag, E1> imag(E1 &&x)

Returns the imaginary part of the complex value

Source code

template <typename E1, KFR_ENABLE_IF(is_input_expression<E1>)>
KFR_INTRINSIC internal::expression_function<fn::imag, E1> imag(E1&& x)
{
    return { fn::imag{}, std::forward<E1>(x) };
}

https://github.com/kfrlib/kfr/blob//include/kfr/simd/complex.hpp#L409

`isreal` function¶

template <typename T> bool isreal(const complex<T> &x)

Returns mask with true for real elements

Source code

template <typename T>
KFR_INTRINSIC bool isreal(const complex<T>& x)
{
    return x.imag() == 0;
}

https://github.com/kfrlib/kfr/blob//include/kfr/simd/complex.hpp#L313

`make_complex` function¶

template <typename T1, typename T2 = T1, size_t N,
          typename T = common_type<T1, T2>>
constexpr vec<complex<T>, N>
make_complex(const vec<T1, N> &real,
             const vec<T2, N> &imag = T2(0))

Constructs complex value from real and imaginary parts

Source code

template <typename T1, typename T2 = T1, size_t N, typename T = common_type<T1, T2>>
constexpr KFR_INTRINSIC vec<complex<T>, N> make_complex(const vec<T1, N>& real,
                                                        const vec<T2, N>& imag = T2(0))
{
    return ccomp(interleave(innercast<T>(real), innercast<T>(imag)));
}

https://github.com/kfrlib/kfr/blob//include/kfr/simd/complex.hpp#L416

template <typename T1, typename T2 = T1,
          typename T = common_type<T1, T2>,
          KFR_ENABLE_IF(is_numeric_args<T1, T2>)>
constexpr complex<T> make_complex(T1 real, T2 imag = T2(0))

Constructs complex value from real and imaginary parts

Source code

template <typename T1, typename T2 = T1, typename T = common_type<T1, T2>,
          KFR_ENABLE_IF(is_numeric_args<T1, T2>)>
constexpr KFR_INTRINSIC complex<T> make_complex(T1 real, T2 imag = T2(0))
{
    return complex<T>(innercast<T>(real), innercast<T>(imag));
}

https://github.com/kfrlib/kfr/blob//include/kfr/simd/complex.hpp#L425

template <typename E1, typename E2,
          KFR_ENABLE_IF(is_input_expressions<E1, E2>)>
internal::expression_function<fn::make_complex, E1, E2>
make_complex(E1 &&re, E2 &&im)

Constructs complex value from real and imaginary parts

Source code

template <typename E1, typename E2, KFR_ENABLE_IF(is_input_expressions<E1, E2>)>
KFR_INTRINSIC internal::expression_function<fn::make_complex, E1, E2> make_complex(E1&& re, E2&& im)
{
    return { fn::make_complex{}, std::forward<E1>(re), std::forward<E2>(im) };
}

https://github.com/kfrlib/kfr/blob//include/kfr/simd/complex.hpp#L433

`polar` function¶

template <typename T1, KFR_ENABLE_IF(is_numeric<T1>)>
T1 polar(const T1 &x)

Converts complex number to polar

Source code

template <typename T1, KFR_ENABLE_IF(is_numeric<T1>)>
KFR_FUNCTION T1 polar(const T1& x)
{
    return intrinsics::polar(x);
}

https://github.com/kfrlib/kfr/blob//include/kfr/math/complex_math.hpp#L404

template <typename E1,
          KFR_ENABLE_IF(is_input_expression<E1>)>
internal::expression_function<fn::polar, E1> polar(E1 &&x)

Returns template expression that converts complex number to polar

Source code

template <typename E1, KFR_ENABLE_IF(is_input_expression<E1>)>
KFR_FUNCTION internal::expression_function<fn::polar, E1> polar(E1&& x)
{
    return { fn::polar(), std::forward<E1>(x) };
}

https://github.com/kfrlib/kfr/blob//include/kfr/math/complex_math.hpp#L411

`real` function¶

template <typename T, KFR_ENABLE_IF(is_numeric<T>)>
constexpr T real(const T &value)

Returns the real part of the complex value

Source code

template <typename T, KFR_ENABLE_IF(is_numeric<T>)>
constexpr KFR_INTRINSIC T real(const T& value)
{
    return value;
}

https://github.com/kfrlib/kfr/blob//include/kfr/simd/complex.hpp#L359

template <typename T>
constexpr T real(const complex<T> &value)

Returns the real part of the complex value

Source code

template <typename T>
constexpr KFR_INTRINSIC T real(const complex<T>& value)
{
    return value.real();
}

https://github.com/kfrlib/kfr/blob//include/kfr/simd/complex.hpp#L366

template <typename T, size_t N>
constexpr vec<T, N> real(const vec<complex<T>, N> &value)

Returns the real part of the complex value

Source code

template <typename T, size_t N>
constexpr KFR_INTRINSIC vec<T, N> real(const vec<complex<T>, N>& value)
{
    return even(cdecom(value));
}

https://github.com/kfrlib/kfr/blob//include/kfr/simd/complex.hpp#L373

template <typename E1,
          KFR_ENABLE_IF(is_input_expression<E1>)>
internal::expression_function<fn::real, E1> real(E1 &&x)

Returns the real part of the complex value

Source code

template <typename E1, KFR_ENABLE_IF(is_input_expression<E1>)>
KFR_INTRINSIC internal::expression_function<fn::real, E1> real(E1&& x)
{
    return { fn::real{}, std::forward<E1>(x) };
}

https://github.com/kfrlib/kfr/blob//include/kfr/simd/complex.hpp#L387

Auto-generated from sources, Revision , https://github.com/kfrlib/kfr/blob//include/kfr/

Complex functions¶

c32 typedef¶

c64 typedef¶

cabs function¶

cabssqr function¶

carg function¶

cartesian function¶

cbase typedef¶

cconj function¶

ccos function¶

ccosh function¶

cdupimag function¶

cdupreal function¶

cexp function¶

cexp10 function¶

cexp2 function¶

clog function¶

clog10 function¶

clog2 function¶

cnegimag function¶

cnegreal function¶

complex class¶

csin function¶

csinh function¶

csqr function¶

csqrt function¶

cswapreim function¶

imag function¶

isreal function¶

make_complex function¶

polar function¶

real function¶

`c32` typedef¶

`c64` typedef¶

`cabs` function¶

`cabssqr` function¶

`carg` function¶

`cartesian` function¶

`cbase` typedef¶

`cconj` function¶

`ccos` function¶

`ccosh` function¶

`cdupimag` function¶

`cdupreal` function¶

`cexp` function¶

`cexp10` function¶

`cexp2` function¶

`clog` function¶

`clog10` function¶

`clog2` function¶

`cnegimag` function¶

`cnegreal` function¶

`complex` class¶

`csin` function¶

`csinh` function¶

`csqr` function¶

`csqrt` function¶

`cswapreim` function¶

`imag` function¶

`isreal` function¶

`make_complex` function¶

`polar` function¶

`real` function¶