Imaginary<T> Structure

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

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

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

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

Inheritance

Object  →  ValueType  →  Imaginary<T>

Implements

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

Type Parameters

T

The imaginary value type represents a complex value made of a zero real part and an imaginary part of type T.

Imaginary numbers are a special kind of 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 imaginary structure provides methods for all the common operations on imaginary numbers. The Im returns the imaginary part of the imaginary number. 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.

Binary operations are defined between imaginary numbers and real, imaginary, and complex numbers. The type of the result depends on the combination of operands. For example, multiplying two imaginary numbers results in a real number.

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(Imaginary<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