Complex Struct

Definition

Namespace:

System.Numerics

Assembly:

System.Runtime.Numerics.dll

Represents a complex number.

public value class Complex : IEquatable<System::Numerics::Complex>, IParsable<System::Numerics::Complex>, ISpanParsable<System::Numerics::Complex>, System::Numerics::IAdditionOperators<System::Numerics::Complex, System::Numerics::Complex, System::Numerics::Complex>, System::Numerics::IAdditiveIdentity<System::Numerics::Complex, System::Numerics::Complex>, System::Numerics::IDecrementOperators<System::Numerics::Complex>, System::Numerics::IDivisionOperators<System::Numerics::Complex, System::Numerics::Complex, System::Numerics::Complex>, System::Numerics::IEqualityOperators<System::Numerics::Complex, System::Numerics::Complex, bool>, System::Numerics::IIncrementOperators<System::Numerics::Complex>, System::Numerics::IMultiplicativeIdentity<System::Numerics::Complex, System::Numerics::Complex>, System::Numerics::IMultiplyOperators<System::Numerics::Complex, System::Numerics::Complex, System::Numerics::Complex>, System::Numerics::INumberBase<System::Numerics::Complex>, System::Numerics::ISignedNumber<System::Numerics::Complex>, System::Numerics::ISubtractionOperators<System::Numerics::Complex, System::Numerics::Complex, System::Numerics::Complex>, System::Numerics::IUnaryNegationOperators<System::Numerics::Complex, System::Numerics::Complex>, System::Numerics::IUnaryPlusOperators<System::Numerics::Complex, System::Numerics::Complex>

public readonly struct Complex : IEquatable<System.Numerics.Complex>, IParsable<System.Numerics.Complex>, ISpanParsable<System.Numerics.Complex>, System.Numerics.IAdditionOperators<System.Numerics.Complex,System.Numerics.Complex,System.Numerics.Complex>, System.Numerics.IAdditiveIdentity<System.Numerics.Complex,System.Numerics.Complex>, System.Numerics.IDecrementOperators<System.Numerics.Complex>, System.Numerics.IDivisionOperators<System.Numerics.Complex,System.Numerics.Complex,System.Numerics.Complex>, System.Numerics.IEqualityOperators<System.Numerics.Complex,System.Numerics.Complex,bool>, System.Numerics.IIncrementOperators<System.Numerics.Complex>, System.Numerics.IMultiplicativeIdentity<System.Numerics.Complex,System.Numerics.Complex>, System.Numerics.IMultiplyOperators<System.Numerics.Complex,System.Numerics.Complex,System.Numerics.Complex>, System.Numerics.INumberBase<System.Numerics.Complex>, System.Numerics.ISignedNumber<System.Numerics.Complex>, System.Numerics.ISubtractionOperators<System.Numerics.Complex,System.Numerics.Complex,System.Numerics.Complex>, System.Numerics.IUnaryNegationOperators<System.Numerics.Complex,System.Numerics.Complex>, System.Numerics.IUnaryPlusOperators<System.Numerics.Complex,System.Numerics.Complex>

type Complex = struct
    interface IFormattable
    interface IParsable<Complex>
    interface ISpanFormattable
    interface ISpanParsable<Complex>
    interface IAdditionOperators<Complex, Complex, Complex>
    interface IAdditiveIdentity<Complex, Complex>
    interface IDecrementOperators<Complex>
    interface IDivisionOperators<Complex, Complex, Complex>
    interface IEqualityOperators<Complex, Complex, bool>
    interface IIncrementOperators<Complex>
    interface IMultiplicativeIdentity<Complex, Complex>
    interface IMultiplyOperators<Complex, Complex, Complex>
    interface INumberBase<Complex>
    interface ISubtractionOperators<Complex, Complex, Complex>
    interface IUnaryNegationOperators<Complex, Complex>
    interface IUnaryPlusOperators<Complex, Complex>
    interface ISignedNumber<Complex>

Public Structure Complex
Implements IAdditionOperators(Of Complex, Complex, Complex), IAdditiveIdentity(Of Complex, Complex), IDecrementOperators(Of Complex), IDivisionOperators(Of Complex, Complex, Complex), IEqualityOperators(Of Complex, Complex, Boolean), IEquatable(Of Complex), IIncrementOperators(Of Complex), IMultiplicativeIdentity(Of Complex, Complex), IMultiplyOperators(Of Complex, Complex, Complex), INumberBase(Of Complex), IParsable(Of Complex), ISignedNumber(Of Complex), ISpanParsable(Of Complex), ISubtractionOperators(Of Complex, Complex, Complex), IUnaryNegationOperators(Of Complex, Complex), IUnaryPlusOperators(Of Complex, Complex)

Inheritance

Object

ValueType

Complex

Implements

IEquatable<Complex> IFormattable IEquatable<TSelf> IParsable<Complex> IParsable<TSelf> ISpanFormattable ISpanParsable<Complex> ISpanParsable<TSelf> IAdditionOperators<Complex,Complex,Complex> IAdditionOperators<TSelf,TSelf,TSelf> IAdditiveIdentity<Complex,Complex> IAdditiveIdentity<TSelf,TSelf> IDecrementOperators<Complex> IDecrementOperators<TSelf> IDivisionOperators<Complex,Complex,Complex> IDivisionOperators<TSelf,TSelf,TSelf> IEqualityOperators<Complex,Complex,Boolean> IEqualityOperators<TSelf,TSelf,Boolean> IIncrementOperators<Complex> IIncrementOperators<TSelf> IMultiplicativeIdentity<Complex,Complex> IMultiplicativeIdentity<TSelf,TSelf> IMultiplyOperators<Complex,Complex,Complex> IMultiplyOperators<TSelf,TSelf,TSelf> INumberBase<Complex> INumberBase<TSelf> ISignedNumber<Complex> ISubtractionOperators<Complex,Complex,Complex> ISubtractionOperators<TSelf,TSelf,TSelf> IUnaryNegationOperators<Complex,Complex> IUnaryNegationOperators<TSelf,TSelf> IUnaryPlusOperators<Complex,Complex> IUnaryPlusOperators<TSelf,TSelf>

Remarks

A complex number is a number that comprises a real number part and an imaginary number part. A complex number z is usually written in the form z = x + yi, where x and y are real numbers, and i is the imaginary unit that has the property i² = -1. The real part of the complex number is represented by x, and the imaginary part of the complex number is represented by y.

The Complex type uses the Cartesian coordinate system (real, imaginary) when instantiating and manipulating complex numbers. A complex number can be represented as a point in a two-dimensional coordinate system, which is known as the complex plane. The real part of the complex number is positioned on the x-axis (the horizontal axis), and the imaginary part is positioned on the y-axis (the vertical axis).

Any point in the complex plane can also be expressed based on its absolute value, by using the polar coordinate system. In polar coordinates, a point is characterized by two numbers:

• Its magnitude, which is the distance of the point from the origin (that is, 0,0, or the point at which the x-axis and the y-axis intersect).

• Its phase, which is the angle between the real axis and the line drawn from the origin to the point.

Instantiating a Complex Number

You can assign a value to a complex number in one of the following ways:

• By passing two Double values to its constructor. The first value represents the real part of the complex number, and the second value represents its imaginary part. These values represent the position of the complex number in the two-dimensional Cartesian coordinate system.

• By calling the static (Shared in Visual Basic) Complex.FromPolarCoordinates method to create a complex number from its polar coordinates.

• By assigning a Byte, SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, Single, or Double value to a Complex object. The value becomes the real part of the complex number, and its imaginary part equals 0.

• By casting (in C#) or converting (in Visual Basic) a Decimal or BigInteger value to a Complex object. The value becomes the real part of the complex number, and its imaginary part equals 0.

• By assigning the complex number that is returned by a method or operator to a Complex object. For example, Complex.Add is a static method that returns a complex number that is the sum of two complex numbers, and the Complex.Addition operator adds two complex numbers and returns the result.

The following example demonstrates each of these five ways of assigning a value to a complex number.

using System;
using System.Numerics;

public class Example
{
   public static void Main()
   {
      // Create a complex number by calling its class constructor.
      Complex c1 = new Complex(12, 6);
      Console.WriteLine(c1);

      // Assign a Double to a complex number.
      Complex c2 = 3.14;
      Console.WriteLine(c2);

      // Cast a Decimal to a complex number.
      Complex c3 = (Complex) 12.3m;
      Console.WriteLine(c3);

      // Assign the return value of a method to a Complex variable.
      Complex c4 = Complex.Pow(Complex.One, -1);
      Console.WriteLine(c4);

      // Assign the value returned by an operator to a Complex variable.
      Complex c5 = Complex.One + Complex.One;
      Console.WriteLine(c5);

      // Instantiate a complex number from its polar coordinates.
      Complex c6 = Complex.FromPolarCoordinates(10, .524);
      Console.WriteLine(c6);
   }
}
// The example displays the following output:
//       (12, 6)
//       (3.14, 0)
//       (12.3, 0)
//       (1, 0)
//       (2, 0)
//       (8.65824721882145, 5.00347430269914)

Imports System.Numerics

Module Example
   Public Sub Main()
      ' Create a complex number by calling its class constructor.
      Dim c1 As New Complex(12, 6)
      Console.WriteLine(c1)
      
      ' Assign a Double to a complex number.
      Dim c2 As Complex = 3.14
      Console.WriteLine(c2)
      
      ' Cast a Decimal to a complex number.
      Dim c3 As Complex = CType(12.3d, Complex)
      Console.WriteLine(c3)
      
      ' Assign the return value of a method to a Complex variable.
      Dim c4 As Complex = Complex.Pow(Complex.One, -1)
      Console.WriteLine(c4)
      
      ' Assign the value returned by an operator to a Complex variable.
      Dim c5 As Complex = Complex.One + Complex.One
      Console.WriteLine(c5)

      ' Instantiate a complex number from its polar coordinates.
      Dim c6 As Complex = Complex.FromPolarCoordinates(10, .524)
      Console.WriteLine(c6)
   End Sub
End Module
' The example displays the following output:
'       (12, 6)
'       (3.14, 0)
'       (12.3000001907349, 0)
'       (1, 0)
'       (2, 0)
'       (8.65824721882145, 5.00347430269914)

Operations with Complex Numbers

The Complex structure in the .NET Framework includes members that provide the following functionality:

• Methods to compare two complex numbers to determine whether they are equal.

• Operators to perform arithmetic operations on complex numbers. Complex operators enable you to perform addition, subtraction, multiplication, division, and unary negation with complex numbers.

• Methods to perform other numerical operations on complex numbers. In addition to the four basic arithmetic operations, you can raise a complex number to a specified power, find the square root of a complex number, and get the absolute value of a complex number.

• Methods to perform trigonometric operations on complex numbers. For example, you can calculate the tangent of an angle represented by a complex number.

Note that, because the Real and Imaginary properties are read-only, you cannot modify the value of an existing Complex object. All methods that perform an operation on a Complex number, if their return value is of type Complex, return a new Complex number.

Precision and Complex Numbers

The real and imaginary parts of a complex number are represented by two double-precision floating-point values. This means that Complex values, like double-precision floating-point values, can lose precision as a result of numerical operations. This means that strict comparisons for equality of two Complex values may fail, even if the difference between the two values is due to a loss of precision. For more information, see Double.

For example, performing exponentiation on the logarithm of a number should return the original number. However, in some cases, the loss of precision of floating-point values can cause slight differences between the two values, as the following example illustrates.

Complex value = new Complex(Double.MinValue/2, Double.MinValue/2);
Complex value2 = Complex.Exp(Complex.Log(value));
Console.WriteLine("{0} \n{1} \nEqual: {2}", value, value2,
                                            value == value2);
// The example displays the following output:
//    (-8.98846567431158E+307, -8.98846567431158E+307)
//    (-8.98846567431161E+307, -8.98846567431161E+307)
//    Equal: False

Dim value As New Complex(Double.MinValue/2, Double.MinValue/2)
Dim value2 As Complex = Complex.Exp(Complex.Log(value))
Console.WriteLine("{0} {3}{1} {3}Equal: {2}", value, value2, 
                                              value = value2,
                                              vbCrLf)
' The example displays the following output:
'    (-8.98846567431158E+307, -8.98846567431158E+307)
'    (-8.98846567431161E+307, -8.98846567431161E+307)
'    Equal: False

Similarly, the following example, which calculates the square root of a Complex number, produces slightly different results on the 32-bit and IA64 versions of the .NET Framework.

Complex minusOne = new Complex(-1, 0);
Console.WriteLine(Complex.Sqrt(minusOne));
// The example displays the following output:
//    (6.12303176911189E-17, 1) on 32-bit systems.
//    (6.12323399573677E-17,1) on IA64 systems.

Dim minusOne As New Complex(-1, 0)
Console.WriteLine(Complex.Sqrt(minusOne))
' The example displays the following output:
'    (6.12303176911189E-17, 1) on 32-bit systems.
'    (6.12323399573677E-17,1) on IA64 systems.

Complex Numbers, Infinity, and NaN

The real and imaginary parts of a complex number are represented by Double values. In addition to ranging from Double.MinValue to Double.MaxValue, the real or imaginary part of a complex number can have a value of Double.PositiveInfinity, Double.NegativeInfinity, or Double.NaN. Double.PositiveInfinity, Double.NegativeInfinity, and Double.NaN all propagate in any arithmetic or trigonometric operation.

In the following example, division by Zero produces a complex number whose real and imaginary parts are both Double.NaN. As a result, performing multiplication with this value also produces a complex number whose real and imaginary parts are Double.NaN. Similarly, performing a multiplication that overflows the range of the Double type produces a complex number whose real part is Double.NaN and whose imaginary part is Double.PositiveInfinity. Subsequently performing division with this complex number returns a complex number whose real part is Double.NaN and whose imaginary part is Double.PositiveInfinity.

using System;
using System.Numerics;

public class Example
{
   public static void Main()
   {
      Complex c1 = new Complex(Double.MaxValue / 2, Double.MaxValue /2);

      Complex c2 = c1 / Complex.Zero;
      Console.WriteLine(c2.ToString());
      c2 = c2 * new Complex(1.5, 1.5);
      Console.WriteLine(c2.ToString());
      Console.WriteLine();

      Complex c3 = c1 * new Complex(2.5, 3.5);
      Console.WriteLine(c3.ToString());
      c3 = c3 + new Complex(Double.MinValue / 2, Double.MaxValue / 2);
      Console.WriteLine(c3);
   }
}
// The example displays the following output:
//       (NaN, NaN)
//       (NaN, NaN)
//       (NaN, Infinity)
//       (NaN, Infinity)

Imports System.Numerics

Module Example
   Public Sub Main()
      Dim c1 As Complex = New Complex(Double.MaxValue / 2, Double.MaxValue /2)

      Dim c2 As Complex = c1 / Complex.Zero
      Console.WriteLine(c2.ToString())
      c2 = c2 * New Complex(1.5, 1.5)
      Console.WriteLine(c2.ToString())
      Console.WriteLine()
      
      Dim c3 As Complex = c1 * New Complex(2.5, 3.5)
      Console.WriteLine(c3.ToString())
      c3 = c3 + New Complex(Double.MinValue / 2, Double.MaxValue / 2) 
      Console.WriteLine(c3)     
   End Sub
End Module
' The example displays the following output:
'       (NaN, NaN)
'       (NaN, NaN)
'
'       (NaN, Infinity)
'       (NaN, Infinity)

Mathematical operations with complex numbers that are invalid or that overflow the range of the Double data type do not throw an exception. Instead, they return a Double.PositiveInfinity, Double.NegativeInfinity, or Double.NaN under the following conditions:

• The division of a positive number by zero returns Double.PositiveInfinity.

• Any operation that overflows the upper bound of the Double data type returns Double.PositiveInfinity.

• The division of a negative number by zero returns Double.NegativeInfinity.

• Any operation that overflows the lower bound of the Double data type returns Double.NegativeInfinity.

• The division of a zero by zero returns Double.NaN.

• Any operation that is performed on operands whose values are Double.PositiveInfinity, Double.NegativeInfinity, or Double.NaN returns Double.PositiveInfinity, Double.NegativeInfinity, or Double.NaN, depending on the specific operation.

Note that this applies to any intermediate calculations performed by a method. For example, the multiplication of new Complex(9e308, 9e308) and new Complex(2.5, 3.5) uses the formula (ac - bd) + (ad + bc)i. The calculation of the real component that results from the multiplication evaluates the expression 9e308 * 2.5 - 9e308 * 3.5. Each intermediate multiplication in this expression returns Double.PositiveInfinity, and the attempt to subtract Double.PositiveInfinity from Double.PositiveInfinity returns Double.NaN.

Formatting a Complex Number

By default, the string representation of a complex number takes the form (real, imaginary), where real and imaginary are the string representations of the Double values that form the complex number's real and imaginary components. Some overloads of the ToString method allow customization of the string representations of these Double values to reflect the formatting conventions of a particular culture or to appear in a particular format defined by a standard or custom numeric format string. (For more information, see Standard Numeric Format Strings and Custom Numeric Format Strings.)

One of the more common ways of expressing the string representation of a complex number takes the form a + bi, where a is the complex number's real component, and b is the complex number's imaginary component. In electrical engineering, a complex number is most commonly expressed as a + bj. You can return the string representation of a complex number in either of these two forms. To do this, define a custom format provider by implementing the ICustomFormatter and IFormatProvider interfaces, and then call the String.Format(IFormatProvider, String, Object[]) method.

The following example defines a ComplexFormatter class that represents a complex number as a string in the form of either a + bi or a + bj.

using System;
using System.Numerics;

public class ComplexFormatter :IFormatProvider, ICustomFormatter
{
   public object GetFormat(Type formatType)
   {
      if (formatType == typeof(ICustomFormatter))
         return this;
      else
         return null;
   }

   public string Format(string format, object arg,
                        IFormatProvider provider)
   {
      if (arg is Complex)
      {
         Complex c1 = (Complex) arg;
         // Check if the format string has a precision specifier.
         int precision;
         string fmtString = String.Empty;
         if (format.Length > 1) {
            try {
               precision = Int32.Parse(format.Substring(1));
            }
            catch (FormatException) {
               precision = 0;
            }
            fmtString = "N" + precision.ToString();
         }
         if (format.Substring(0, 1).Equals("I", StringComparison.OrdinalIgnoreCase))
            return c1.Real.ToString(fmtString) + " + " + c1.Imaginary.ToString(fmtString) + "i";
         else if (format.Substring(0, 1).Equals("J", StringComparison.OrdinalIgnoreCase))
            return c1.Real.ToString(fmtString) + " + " + c1.Imaginary.ToString(fmtString) + "j";
         else
            return c1.ToString(format, provider);
      }
      else
      {
         if (arg is IFormattable)
            return ((IFormattable) arg).ToString(format, provider);
         else if (arg != null)
            return arg.ToString();
         else
            return String.Empty;
      }
   }
}

Imports System.Numerics

Public Class ComplexFormatter 
             Implements IFormatProvider, ICustomFormatter
   
   Public Function GetFormat(formatType As Type) As Object _
                   Implements IFormatProvider.GetFormat
      If formatType Is GetType(ICustomFormatter) Then
         Return Me
      Else
         Return Nothing
      End If
   End Function
   
   Public Function Format(fmt As String, arg As Object, 
                          provider As IFormatProvider) As String _
                   Implements ICustomFormatter.Format
      If TypeOf arg Is Complex Then
         Dim c1 As Complex = DirectCast(arg, Complex)
         ' Check if the format string has a precision specifier.
         Dim precision As Integer
         Dim fmtString As String = String.Empty
         If fmt.Length > 1 Then
            Try
               precision = Int32.Parse(fmt.Substring(1))
            Catch e As FormatException
               precision = 0
            End Try
            fmtString = "N" + precision.ToString()
         End If
         If fmt.Substring(0, 1).Equals("I", StringComparison.OrdinalIgnoreCase) Then
            Return c1.Real.ToString(fmtString) + " + " + c1.Imaginary.ToString(fmtString) + "i"
         ElseIf fmt.Substring(0, 1).Equals("J", StringComparison.OrdinalIgnoreCase) Then
            Return c1.Real.ToString(fmtString) + " + " + c1.Imaginary.ToString(fmtString) + "j"
         Else
            Return c1.ToString(fmt, provider)
         End If
      Else
         If Typeof arg Is IFormattable Then
            Return DirectCast(arg, IFormattable).ToString(fmt, provider)
         ElseIf arg IsNot Nothing Then
            Return arg.ToString()
         Else
            Return String.Empty
         End If   
      End If                        
   End Function
End Class

The following example then uses this custom formatter to display the string representation of a complex number.

public class Example
{
   public static void Main()
   {
      Complex c1 = new Complex(12.1, 15.4);
      Console.WriteLine("Formatting with ToString():       " +
                        c1.ToString());
      Console.WriteLine("Formatting with ToString(format): " +
                        c1.ToString("N2"));
      Console.WriteLine("Custom formatting with I0:        " +
                        String.Format(new ComplexFormatter(), "{0:I0}", c1));
      Console.WriteLine("Custom formatting with J3:        " +
                        String.Format(new ComplexFormatter(), "{0:J3}", c1));
   }
}
// The example displays the following output:
//    Formatting with ToString():       (12.1, 15.4)
//    Formatting with ToString(format): (12.10, 15.40)
//    Custom formatting with I0:        12 + 15i
//    Custom formatting with J3:        12.100 + 15.400j

Module Example
   Public Sub Main()
      Dim c1 As Complex = New Complex(12.1, 15.4)
      Console.WriteLine("Formatting with ToString():       " + 
                        c1.ToString())
      Console.WriteLine("Formatting with ToString(format): " + 
                        c1.ToString("N2"))
      Console.WriteLine("Custom formatting with I0:        " + 
                        String.Format(New ComplexFormatter(), "{0:I0}", c1))
      Console.WriteLine("Custom formatting with J3:        " + 
                        String.Format(New ComplexFormatter(), "{0:J3}", c1))
   End Sub
End Module
' The example displays the following output:
'    Formatting with ToString():       (12.1, 15.4)
'    Formatting with ToString(format): (12.10, 15.40)
'    Custom formatting with I0:        12 + 15i
'    Custom formatting with J3:        12.100 + 15.400j

Constructors

Complex(Double, Double)

Initializes a new instance of the Complex structure using the specified real and imaginary values.

Fields

ImaginaryOne	Returns a new Complex instance with a real number equal to zero and an imaginary number equal to one.
Infinity	Represents infinity as a complex number.
NaN	Represents a complex instance that is not a number (NaN).
One	Returns a new Complex instance with a real number equal to one and an imaginary number equal to zero.
Zero	Returns a new Complex instance with a real number equal to zero and an imaginary number equal to zero.

Properties

Imaginary	Gets the imaginary component of the current Complex object.
Magnitude	Gets the magnitude (or absolute value) of a complex number.
Phase	Gets the phase of a complex number.
Real	Gets the real component of the current Complex object.

Methods

Abs(Complex)	Gets the absolute value (or magnitude) of a complex number.
Acos(Complex)	Returns the angle that is the arc cosine of the specified complex number.
Add(Complex, Complex)	Adds two complex numbers and returns the result.
Add(Complex, Double)	Adds a complex number to a double-precision real number and returns the result.
Add(Double, Complex)	Adds a double-precision real number to a complex number and returns the result.
Asin(Complex)	Returns the angle that is the arc sine of the specified complex number.
Atan(Complex)	Returns the angle that is the arc tangent of the specified complex number.
Conjugate(Complex)	Computes the conjugate of a complex number and returns the result.
Cos(Complex)	Returns the cosine of the specified complex number.
Cosh(Complex)	Returns the hyperbolic cosine of the specified complex number.
CreateChecked<TOther>(TOther)	Creates an instance of the current type from a value, throwing an overflow exception for any values that fall outside the representable range of the current type.
CreateSaturating<TOther>(TOther)	Creates an instance of the current type from a value, saturating any values that fall outside the representable range of the current type.
CreateTruncating<TOther>(TOther)	Creates an instance of the current type from a value, truncating any values that fall outside the representable range of the current type.
Divide(Complex, Complex)	Divides one complex number by another and returns the result.
Divide(Complex, Double)	Divides one complex number by a double-precision real number and returns the result.
Divide(Double, Complex)	Divides one double-precision real number by a complex number and returns the result.
Equals(Complex)	Returns a value that indicates whether the current instance and a specified complex number have the same value.
Equals(Object)	Returns a value that indicates whether the current instance and a specified object have the same value.
Exp(Complex)	Returns e raised to the power specified by a complex number.
FromPolarCoordinates(Double, Double)	Creates a complex number from a point's polar coordinates.
GetHashCode()	Returns the hash code for the current Complex object.
IsComplexNumber(Complex)	Determines if a value represents a complex value.
IsEvenInteger(Complex)	Determines if a value represents an even integral number.
IsFinite(Complex)	Determines whether the specified complex number is finite.
IsImaginaryNumber(Complex)	Determines if a value represents an imaginary number.
IsInfinity(Complex)	Returns a value indicating whether the specified complex number evaluates to infinity.
IsInteger(Complex)	Determines if a value represents an integral value.
IsNaN(Complex)	Returns a value that indicates whether the specified complex instance is not a number (NaN).
IsNegative(Complex)	Determines if a value is negative.
IsNegativeInfinity(Complex)	Determines if a value is negative infinity.
IsNormal(Complex)	Determines if a value is normal.
IsOddInteger(Complex)	Determines if a value represents an odd integral number.
IsPositive(Complex)	Determines if a value is positive.
IsPositiveInfinity(Complex)	Determines if a value is positive infinity.
IsRealNumber(Complex)	Determines if a value represents a real number.
IsSubnormal(Complex)	Determines if a value is subnormal.
Log(Complex)	Returns the natural (base e) logarithm of a specified complex number.
Log(Complex, Double)	Returns the logarithm of a specified complex number in a specified base.
Log10(Complex)	Returns the base-10 logarithm of a specified complex number.
MaxMagnitude(Complex, Complex)	Compares two values to compute which is greater.
MinMagnitude(Complex, Complex)	Compares two values to compute which is lesser.
Multiply(Complex, Complex)	Returns the product of two complex numbers.
Multiply(Complex, Double)	Returns the product of a complex number and a double-precision real number.
Multiply(Double, Complex)	Returns the product of a double-precision real number and a complex number.
Negate(Complex)	Returns the additive inverse of a specified complex number.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Parses a span of characters into a value.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Parses a span of characters into a value.
Parse(String, IFormatProvider)	Parses a string into a value.
Parse(String, NumberStyles, IFormatProvider)	Parses a string into a value.
Pow(Complex, Complex)	Returns a specified complex number raised to a power specified by a complex number.
Pow(Complex, Double)	Returns a specified complex number raised to a power specified by a double-precision floating-point number.
Reciprocal(Complex)	Returns the multiplicative inverse of a complex number.
Sin(Complex)	Returns the sine of the specified complex number.
Sinh(Complex)	Returns the hyperbolic sine of the specified complex number.
Sqrt(Complex)	Returns the square root of a specified complex number.
Subtract(Complex, Complex)	Subtracts one complex number from another and returns the result.
Subtract(Complex, Double)	Subtracts one double-precision real number from a complex number and returns the result.
Subtract(Double, Complex)	Subtracts one complex number from a double-precision real number and returns the result.
Tan(Complex)	Returns the tangent of the specified complex number.
Tanh(Complex)	Returns the hyperbolic tangent of the specified complex number.
ToString()	Converts the value of the current complex number to its equivalent string representation in Cartesian form.
ToString(IFormatProvider)	Converts the value of the current complex number to its equivalent string representation in Cartesian form by using the specified culture-specific formatting information.
ToString(String)	Converts the value of the current complex number to its equivalent string representation in Cartesian form by using the specified format for its real and imaginary parts.
ToString(String, IFormatProvider)	Converts the value of the current complex number to its equivalent string representation in Cartesian form by using the specified format and culture-specific format information for its real and imaginary parts.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Tries to format the value of the current instance into the provided span of characters.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Complex)	Tries to parse a span of characters into a value.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Complex)	Tries to parse a span of characters into a value.
TryParse(String, IFormatProvider, Complex)	Tries to parse a string into a value.
TryParse(String, NumberStyles, IFormatProvider, Complex)	Tries to parse a string into a value.

Operators

Addition(Complex, Complex)	Adds two complex numbers.
Addition(Complex, Double)	Adds a complex number to a double-precision real number.
Addition(Double, Complex)	Adds a double-precision real number to a complex number.
Decrement(Complex)	Decrements a value.
Division(Complex, Complex)	Divides a specified complex number by another specified complex number.
Division(Complex, Double)	Divides a specified complex number by a specified double-precision real number.
Division(Double, Complex)	Divides a specified double-precision real number by a specified complex number.
Equality(Complex, Complex)	Returns a value that indicates whether two complex numbers are equal.
Explicit(BigInteger to Complex)	Defines an explicit conversion of a BigInteger value to a complex number.
Explicit(Decimal to Complex)	Defines an explicit conversion of a Decimal value to a complex number.
Explicit(Int128 to Complex)	Explicitly converts a Int128 value to a double-precision complex number.
Explicit(UInt128 to Complex)	Explicitly converts a UInt128 value to a double-precision complex number.
Implicit(Byte to Complex)	Defines an implicit conversion of an unsigned byte to a complex number.
Implicit(Char to Complex)	Implicitly converts a Char value to a double-precision complex number.
Implicit(Double to Complex)	Defines an implicit conversion of a double-precision floating-point number to a complex number.
Implicit(Half to Complex)	Implicitly converts a Half value to a double-precision complex number.
Implicit(Int16 to Complex)	Defines an implicit conversion of a 16-bit signed integer to a complex number.
Implicit(Int32 to Complex)	Defines an implicit conversion of a 32-bit signed integer to a complex number.
Implicit(Int64 to Complex)	Defines an implicit conversion of a 64-bit signed integer to a complex number.
Implicit(IntPtr to Complex)	Implicitly converts a IntPtr value to a double-precision complex number.
Implicit(SByte to Complex)	Defines an implicit conversion of a signed byte to a complex number. This API is not CLS-compliant.
Implicit(Single to Complex)	Defines an implicit conversion of a single-precision floating-point number to a complex number.
Implicit(UInt16 to Complex)	Defines an implicit conversion of a 16-bit unsigned integer to a complex number. This API is not CLS-compliant.
Implicit(UInt32 to Complex)	Defines an implicit conversion of a 32-bit unsigned integer to a complex number. This API is not CLS-compliant.
Implicit(UInt64 to Complex)	Defines an implicit conversion of a 64-bit unsigned integer to a complex number. This API is not CLS-compliant.
Implicit(UIntPtr to Complex)	Implicitly converts a UIntPtr value to a double-precision complex number.
Increment(Complex)	Increments a value.
Inequality(Complex, Complex)	Returns a value that indicates whether two complex numbers are not equal.
Multiply(Complex, Complex)	Multiplies two specified complex numbers.
Multiply(Complex, Double)	Multiplies the specified complex number by a specified double-precision real number.
Multiply(Double, Complex)	Multiplies a specified double-precision real number by a specified complex number.
Subtraction(Complex, Complex)	Subtracts a complex number from another complex number.
Subtraction(Complex, Double)	Subtracts a double-precision real number from a complex number.
Subtraction(Double, Complex)	Subtracts a complex number from a double-precision real number.
UnaryNegation(Complex)	Returns the additive inverse of a specified complex number.
UnaryPlus(Complex)	Computes the unary plus of a value.

Explicit Interface Implementations

IAdditiveIdentity<Complex,Complex>.AdditiveIdentity

IMultiplicativeIdentity<Complex,Complex>.MultiplicativeIdentity

INumberBase<Complex>.Abs(Complex)

INumberBase<Complex>.IsCanonical(Complex)

INumberBase<Complex>.IsZero(Complex)

INumberBase<Complex>.MaxMagnitudeNumber(Complex, Complex)

INumberBase<Complex>.MinMagnitudeNumber(Complex, Complex)

INumberBase<Complex>.One

INumberBase<Complex>.Radix

INumberBase<Complex>.TryConvertFromChecked<TOther>(TOther, Complex)

INumberBase<Complex>.TryConvertFromSaturating<TOther>(TOther, Complex)

INumberBase<Complex>.TryConvertFromTruncating<TOther>(TOther, Complex)

INumberBase<Complex>.TryConvertToChecked<TOther>(Complex, TOther)

INumberBase<Complex>.TryConvertToSaturating<TOther>(Complex, TOther)

INumberBase<Complex>.TryConvertToTruncating<TOther>(Complex, TOther)

INumberBase<Complex>.Zero

ISignedNumber<Complex>.NegativeOne