Display the source code in std/complex.d from which this page was generated on github.

If you spot a problem with this page, click here to create a Bugzilla issue.

Quickly fork, edit online, and submit a pull request for this page. Requires a signed-in GitHub account. This works well for small changes. If you'd like to make larger changes you may want to consider using local clone.

`std.complex.Complex/complex` - multiple declarations

Function complex

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


						
				auto complex(R)
				(
				

				  const R re
				

				) pure nothrow @nogc @safe
				

				if (is(R : double));
				

				

				auto complex(R, I)
				(
				

				  const R re,
				

				  const I im
				

				) pure nothrow @nogc @safe
				

				if (is(R : double) && is(I : double));

Parameters

Name	Description
R	(template parameter) type of real part of complex number
I	(template parameter) type of imaginary part of complex number
re	real part of complex number to be constructed
im	(optional) imaginary part of complex number, 0 if omitted.

Returns

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 CommonType!(R, I).

Example

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

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

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

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

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

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

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

Struct Complex

A complex number parametrised by a type T, which must be either float, double or real.


						
				struct Complex(T)
				

				  
				

				if (isFloatingPoint!T);

Constructors

Name	Description
`this` (x, y)	Construct a complex number with the specified real and imaginary parts. In the case where a single argument is passed that is not complex, the imaginary part of the result will be zero.

Fields

Name	Type	Description
`im`	`T`	The imaginary part of the number.
`re`	`T`	The real part of the number.

Methods

Name	Description
`toNative` ()	Returns a complex number instance that correponds in size and in ABI to the associated C compiler's `_Complex` type.
`toString` ()	Converts the complex number to a string representation.

Authors

Lars Tandle Kyllingstad, Don Clugston

License

Boost License 1.0