Complex<T> Structure

[SerializableAttribute]
public readonly struct Complex<T> : IEquatable<Complex<T>>, 
	IEquatable<T>, IComparable<Complex<T>>

<SerializableAttribute>
Public Structure Complex(Of T)
	Implements IEquatable(Of Complex(Of T)), IEquatable(Of T), 
	IComparable(Of Complex(Of T))

[SerializableAttribute]
generic<typename T>
public value class Complex : IEquatable<Complex<T>>, 
	IEquatable<T>, IComparable<Complex<T>>

[<SealedAttribute>]
[<SerializableAttribute>]
type Complex<'T> = 
    struct
        inherit ValueType
        interface IEquatable<Complex<'T>>
        interface IEquatable<'T>
        interface IComparable<Complex<'T>>
    end

Inheritance

Object  →  ValueType  →  Complex<T>

Implements

IComparable<Complex<T>>, IEquatable<Complex<T>>, IEquatable<T>

Type Parameters

T

The complex value type represents a complex value made of real and imaginary parts of type T.

Complex numbers arise in algebra in the solution of quadratic equations. The equation x²= –R.One does not have any real solutions. However, if we define a new number, i as the square root of -R.One, then we have two solutions: i and -i.

This, in turn, gives rise to an entirely new class of numbers of the form a + ib with a and b real, and i defined as above. These are the complex numbers.

The complex structure provides methods for all the common operations on complex numbers. The Re property returns the real element of the complex number, while Im returns the imaginary part. Because the complex numbers don't have a natural ordering, only equality and inequality operators are available.

Overloaded versions of the major arithmetic operators are provided for languages that support them. For languages that don't support operator overloading, equivalent static methods are supplied.

When performing binary operations, if one of the operands is a complex, then the other operand is required to be either of type complex or . Prior to performing the operation, if the other operand is not a complex, it is converted to complex. If the operation produces a numeric result, the type of the result is complex.

Exceptions to this are methods that return a real property of a complex number: Phase, Magnitude, MagnitudeSquared and Abs(Complex<T>). These methods return a T value.

If T is a floating-point type, then operations including the assignment operators, do not throw exceptions. Instead, in exceptional situations, the result of a floating-point operation is zero, Infinity, or NaN, as described below:

• If the result of a complex floating-point operation is too small for the destination format, the result of the operation is zero.
• If the magnitude of the complex result of a floating-point operation is too large for the destination format, the result of the operation is Infinity. Directed infinities are currently not supported.
• If a complex floating-point operation is invalid, the result of the operation is NaN.
• If one or both operands of a complex floating-point operation are NaN, the result of the operation is NaN.

Many elementary functions have been extended to the complex domain. These are implemented by static methods.

Some of these functions are multi-valued. If there is one real argument, then any symmetry or anti-symmetry about the origin is preserved. For example, the inverse sine function satisfies asin(-x) == -asin(x) for -1 <= x <= 1. The Asin(Complex<T>) method satisfies this relationship for any real value of x.

For complex arguments, the identity Conjugate(f(x)) == f(Conjugate(x)) is preserved. The branch cuts for all complex functions defined here are along either the real or the imaginary axis. Along the branch cuts, the functions have different values depending on whether the zero element is normal (positive) zero or negative zero.

The real and imaginary parts of complex numbers are real numbers.

Reference