The OpenD Programming Language

complex

Helper function that returns a complex number with the specified real and imaginary parts.

  1. auto complex(R re)
  2. auto complex(R re, I im)
    @safe pure nothrow @nogc
    complex
    (
    R
    I
    )
    (
    const R re
    ,
    const I im
    )
    if (
    is(R : double) &&
    is(I : double)
    )

Parameters

R

(template parameter) type of real part of complex number

I

(template parameter) type of imaginary part of complex number

re R

real part of complex number to be constructed

im I

(optional) imaginary part of complex number, 0 if omitted.

Return Value

Type: auto

Complex instance with real and imaginary parts set to the values provided as input. If neither re nor im are floating-point numbers, the return type will be Complex!double. Otherwise, the return type is deduced using std.traits.CommonType!(R, I).

Examples

auto a = complex(1.0);
static assert(is(typeof(a) == Complex!double));
assert(a.re == 1.0);
assert(a.im == 0.0);

auto b = complex(2.0L);
static assert(is(typeof(b) == Complex!real));
assert(b.re == 2.0L);
assert(b.im == 0.0L);

auto c = complex(1.0, 2.0);
static assert(is(typeof(c) == Complex!double));
assert(c.re == 1.0);
assert(c.im == 2.0);

auto d = complex(3.0, 4.0L);
static assert(is(typeof(d) == Complex!real));
assert(d.re == 3.0);
assert(d.im == 4.0L);

auto e = complex(1);
static assert(is(typeof(e) == Complex!double));
assert(e.re == 1);
assert(e.im == 0);

auto f = complex(1L, 2);
static assert(is(typeof(f) == Complex!double));
assert(f.re == 1L);
assert(f.im == 2);

auto g = complex(3, 4.0L);
static assert(is(typeof(g) == Complex!real));
assert(g.re == 3);
assert(g.im == 4.0L);

Meta