Complex — Complex Numbers

Overview

Complex<T> is a complex number class parameterized over an arbitrary scalar type T. T may be double, float, Int, Float, Rational, or any other type that satisfies the ComplexScalar concept.

• Arbitrary precision support — unlike std::complex, the implementation accepts arbitrary-precision numeric types as the template parameter.
• Strassen 3-multiplication — multiplication uses three real multiplications instead of four, which is a significant speedup for arbitrary-precision arithmetic.
• Smith division — when T = double/float, Smith's method is used to avoid overflow in intermediate values.
• std::complex compatibility — conversion constructors and implicit conversion operators allow bidirectional conversion.
• SIMD-compatible layout — static_assert guarantees that re and im are laid out contiguously, so reinterpret_cast to std::complex<T> is valid.

The ComplexScalar concept requires the following operations:

template<typename T>
concept ComplexScalar = requires(T a, T b) {
    { a + b } -> std::convertible_to<T>;
    { a - b } -> std::convertible_to<T>;
    { a * b } -> std::convertible_to<T>;
    { a / b } -> std::convertible_to<T>;
    { -a }    -> std::convertible_to<T>;
    { T(0) };
    { T(1) };
};

Build

#include <math/core/Complex.hpp>

Header-only. No CMake target or link library is required. Complex.hpp depends only on standard headers such as <complex>, <cmath>, and <concepts>.

Constructors

Accessors

The re and im members are public and may be accessed directly. The .real() / .imag() methods are provided for API compatibility with std::complex.

Arithmetic Operators

Complex-Complex operations

Scalar-mixed operations

Arithmetic between Complex<T> and T is supported with the scalar on either side.

Compound assignment operators

+=, -=, *=, /= are supported for both Complex-Complex and Complex-scalar combinations.

Comparison Operators

Ordering comparisons (<, >, etc.) are not provided because the complex numbers do not admit a natural mathematical ordering.

Mathematical Functions

All functions are free functions in the sangi namespace. They can be called without the namespace prefix thanks to ADL (Argument-Dependent Lookup).

Basic functions

Polar form

Exponential, logarithm, and power

Trigonometric functions

Hyperbolic functions

Inverse trigonometric functions

Inverse hyperbolic functions

User-Defined Literals

Declaring using sangi::literals; enables the following literals.

using sangi::literals;

auto z = 2.0 + 3.0_i;   // Complex<double>(2, 3)
auto w = 1.0 - 0.5_i;   // Complex<double>(1, -0.5)
auto f = 1.0_if + 2.0_if; // Complex<float>(0, 3)

Compatibility with std::complex

Conversion

When T is a floating-point type (float, double, long double), the following conversions are implicit:

// std::complex → Complex
std::complex<double> sc(1.0, 2.0);
Complex<double> z = sc;     // implicit

// Complex → std::complex
Complex<double> w(3.0, 4.0);
std::complex<double> sw = w; // implicit

Memory layout compatibility

Complex<T> guarantees via static_assert that re and im are laid out contiguously in memory. Therefore, an array of Complex<double> can be reinterpreted as an array of std::complex<double> via reinterpret_cast.

// Array reinterpretation
std::vector<Complex<double>> data(1024);
auto* std_ptr = reinterpret_cast<std::complex<double>*>(data.data());
// Can be passed directly to C libraries such as FFTW

The following static_asserts verify the layout at compile time:

• sizeof(Complex<T>) == 2 * sizeof(T)
• offsetof(Complex<T>, re) == 0
• offsetof(Complex<T>, im) == sizeof(T)

auto and Expression Templates

Complex<T> itself does not use expression templates. All operators return Complex<T> directly, so receiving the result with auto is always safe.

auto z = a + b * c;  // OK: Complex<T>

However, when Complex<T> is used as the element type of a container that does use expression templates (such as Matrix<Complex<T>>), receiving the result of a matrix operation with auto may yield an expression-template proxy. In that case, call .eval() or specify the type explicitly.

Matrix<Complex<double>> A, B;
auto expr = A * B;                           // may be a proxy type
Matrix<Complex<double>> C = A * B;          // forces evaluation
auto D = (A * B).eval();                     // explicit evaluation via eval()

Code Example

#include <math/core/Complex.hpp>
#include <iostream>
using namespace sangi;
using namespace sangi::literals;

int main() {
    // Basic construction
    Complex<double> z1(3.0, 4.0);   // 3 + 4i
    Complex<double> z2 = 2.0 + 1.0_i; // 2 + i

    // Arithmetic
    auto sum  = z1 + z2;   // 5 + 5i
    auto prod = z1 * z2;   // (3*2 - 4*1) + (3*1 + 4*2)i = 2 + 11i
    auto quot = z1 / z2;   // computed via Smith's method

    // Mathematical functions
    std::cout << "abs(z1)  = " << abs(z1)  << std::endl;  // 5
    std::cout << "arg(z1)  = " << arg(z1)  << std::endl;  // atan2(4,3)
    std::cout << "conj(z1) = " << conj(z1) << std::endl;  // 3-4i

    // Polar form
    auto w = polar(5.0, 0.9273);  // ≈ 3 + 4i

    // Exponential and logarithm
    auto e_iz = exp(Complex<double>(0.0, M_PI));  // ≈ -1 + 0i (Euler's formula)
    std::cout << "e^(i*pi) = " << e_iz << std::endl;

    // Conversion to/from std::complex
    std::complex<double> sc(1.0, 2.0);
    Complex<double> from_std = sc;
    std::complex<double> to_std = from_std;

    // expI: FFT twiddle factor
    int N = 8;
    for (int k = 0; k < N; ++k) {
        auto twiddle = expI(-2.0 * M_PI * k / N);
        std::cout << "W_" << N << "^" << k << " = " << twiddle << std::endl;
    }
}