Complex 结构

定义

命名空间:: System.Numerics

程序集:: System.Numerics.dll, System.Runtime.Numerics.dll

程序集:: netstandard.dll, System.Runtime.Numerics.dll

程序集:: System.Runtime.Numerics.dll

程序集:: System.Numerics.dll

程序集:: netstandard.dll

Source:: Complex.cs

Source:: Complex.cs

Source:: Complex.cs

Source:: Complex.cs

Source:: Complex.cs

重要

一些信息与预发行产品相关，相应产品在发行之前可能会进行重大修改。对于此处提供的信息，Microsoft 不作任何明示或暗示的担保。

表示复数。

public value class Complex : IEquatable<System::Numerics::Complex>, IFormattable

public value class Complex : IEquatable<System::Numerics::Complex>, IParsable<System::Numerics::Complex>, ISpanParsable<System::Numerics::Complex>, IUtf8SpanParsable<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 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 struct Complex : IEquatable<System.Numerics.Complex>, IFormattable

public readonly struct Complex : IEquatable<System.Numerics.Complex>, IParsable<System.Numerics.Complex>, ISpanParsable<System.Numerics.Complex>, IUtf8SpanParsable<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>, IFormattable

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>

[System.Serializable]
public struct Complex : IEquatable<System.Numerics.Complex>, IFormattable

type Complex = struct
    interface IFormattable

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 IUtf8SpanFormattable
    interface IUtf8SpanParsable<Complex>
    interface ISubtractionOperators<Complex, Complex, Complex>
    interface IUnaryNegationOperators<Complex, Complex>
    interface IUnaryPlusOperators<Complex, Complex>
    interface ISignedNumber<Complex>

type Complex = struct
    interface IFormattable
    interface IParsable<Complex>
    interface ISpanFormattable
    interface ISpanParsable<Complex>
    interface IUtf8SpanFormattable
    interface IUtf8SpanParsable<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>

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>

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 IUtf8SpanFormattable
    interface IUtf8SpanParsable<Complex>
    interface ISignedNumber<Complex>

[<System.Serializable>]
type Complex = struct
    interface IFormattable

Public Structure Complex
Implements IEquatable(Of Complex), IFormattable

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), IUtf8SpanParsable(Of 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)

继承: Object

ValueType
Complex

属性: SerializableAttribute

实现: IEquatable<Complex> IFormattable IEquatable<TSelf> IParsable<Complex> IParsable<TSelf> ISpanFormattable ISpanParsable<Complex> ISpanParsable<TSelf> IUtf8SpanFormattable IUtf8SpanParsable<Complex> IUtf8SpanParsable<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>

注解

复数是包含实数部分和虚数部分的数字。复数 z 通常以形式 z = x + yi编写，其中 x 和 y 是实数， i 是具有属性 i² = -1 的虚构单位。复数的实际部分由 x 表示，复数的虚部由 y 表示。

该 Complex 类型在实例化和操作复数时使用笛卡尔坐标系（真实、虚构）。复数可以表示为二维坐标系中的点，称为复杂平面。复数的实际部分位于 x 轴（水平轴）上，虚部位于 y 轴（垂直轴）上。

使用极坐标系统还可以根据复杂平面中的任何点的绝对值来表示。在极坐标中，一个点由两个数字表示：

其数量级，它是与原点（即 0,0，或 x 轴和 y 轴相交的点）的距离。
其相位是从原点到该点绘制的线条与实轴之间的角度。

实例化复数

可以通过以下方法之一将值分配给复数：

将两个 Double 值传递给其构造函数。第一个值表示复数的实际部分，第二个值表示其虚部。这些值表示二维笛卡尔坐标系中复数的位置。
通过调用静态（Shared 在 Visual Basic 中） Complex.FromPolarCoordinates 方法，从其极坐标创建复数。
通过将Byte、SByte、Int16、UInt16、Int32、UInt32、Int64、UInt64值分配给Single对象来赋予Double值。该值将成为复数的实际部分，其虚部等于 0。
通过在 C# 中将 Decimal 或 BigInteger 值转换为 Complex 对象，或在 Visual Basic 中进行转换。该值将成为复数的实际部分，其虚部等于 0。
通过将方法或运算符 Complex 返回的复数分配给对象。例如，是一个静态方法， Complex.Add 它返回一个复数，该复数是两个复数的总和，运算符 Complex.Addition 添加两个复数并返回结果。

以下示例演示了将值分配给复数的五种方法中的每一种。

using System;
using System.Numerics;

public class CreateEx
{
    public static void Run()
    {
        // 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 Run()
      ' 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)

包含复数的操作

Complex.NET 中的结构包括提供以下功能的成员：

用于比较两个复数的方法，以确定它们是否相等。
用于对复数执行算术运算的运算符。 Complex 运算符使你能够使用复数执行加法、减法、乘法、除法和一元求反。
对复数执行其他数值运算的方法。除了四个基本算术运算外，还可以将复数提升为指定幂，查找复数的平方根，并获取复数的绝对值。
对复数执行三角运算的方法。例如，可以计算由复数表示的角度的正切值。

请注意，由于Real和Imaginary属性是只读的，这意味着您无法修改现有Complex对象的值。对Complex数字进行运算的所有方法，如果其返回值类型是Complex，则返回一个新的Complex数字。

精度和复数

复数的实数和虚部由两个双精度浮点值表示。这意味着 Complex 值（如双精度浮点值）可能会因数值运算而失去精度。这意味着，即使两 Complex 个值之间的差异是由于精度损失，两个值的相等性严格比较也可能失败。有关详细信息，请参阅 Double。

例如，对一个数字的对数进行指数运算应返回该数字本身。但是，在某些情况下，浮点值的精度损失可能会导致两个值之间的细微差异，如以下示例所示。

Complex value = new Complex(Double.MinValue / 2, Double.MinValue / 2);
Complex value2 = Complex.Exp(Complex.Log(value));
Console.WriteLine($"{value} \n{value2} \nEqual: {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

同样，下面的示例计算数字 Complex 的平方根，在 32 位和 IA64 版本的 .NET 上生成略有不同的结果。

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.

无穷大和 NaN

复数的实数和虚部由 Double 值表示。除了从 Double.MinValue 到 Double.MaxValue，复数的实部或虚部还可以取值 Double.PositiveInfinity，Double.NegativeInfinity，或 Double.NaN。 Double.PositiveInfinity、Double.NegativeInfinity和Double.NaN在任何算术或三角运算中都会传播。

在下面的示例中，除以 Zero 产生一个复数，其实数和虚数部分均为 Double.NaN。因此，使用此值进行乘法也会生成一个其实数部分和虚数部分为 Double.NaN 的复数。同样，执行溢出范围的Double乘法会生成一个复数，其实部是Double.NaN，其虚部是Double.PositiveInfinity。随后，使用此复数执行除法将返回一个复数，其实部是Double.NaN，虚部是Double.PositiveInfinity。

using System;
using System.Numerics;

public class NaNEx
{
    public static void Run()
    {
        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 Example4
    Public Sub Run()
        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)

对于复数的数学运算，如果无效或者溢出了 Double 数据类型的范围，程序不会抛出异常。相反，它们在以下条件下返回Double.PositiveInfinity、Double.NegativeInfinity或Double.NaN：

正数除以零返回 Double.PositiveInfinity。
溢出数据类型上限 Double 的任何操作都 Double.PositiveInfinity返回。
负数除以零返回 Double.NegativeInfinity。
溢出数据类型下限 Double 的任何操作都 Double.NegativeInfinity返回。
零除以零返回 Double.NaN。
对操作数值为Double.PositiveInfinity、Double.NegativeInfinity或Double.NaN的任何操作，所返回的结果为Double.PositiveInfinity、Double.NegativeInfinity或Double.NaN，具体取决于特定操作。

请注意，这适用于方法执行的任何中间计算。例如，new Complex(9e308, 9e308) and new Complex(2.5, 3.5) 乘法使用公式 (ac - bd) + (ad + bc)i。乘法结果的实际组件计算表达式 9e308 2.5 - 9e308 3.5。此表达式中的每个中间乘法返回Double.PositiveInfinity，试图从Double.PositiveInfinity中减去Double.PositiveInfinity返回Double.NaN。

设置复数的格式

默认情况下，复数的字符串表示形式为<实部; + 虚部>，其中实部和虚部是构成复数实部和虚部分量的值的字符串表示形式。此方法的某些 ToString 重载允许自定义这些 Double 值的字符串表示形式，以体现特定文化的格式约定，或者以标准或自定义的数字格式字符串定义的特定格式显示。（有关详细信息，请参阅标准数值格式字符串和自定义数字格式字符串。）

表示复数的字符串表示方式之一采用形式 a + bi，其中 a 是复数的实部，b 是复数的虚部。在电气工程中，复数最常表示为 a + bj。返回复数的字符串表示形式可以采用两种形式之一。为此，请通过实现 ICustomFormatter 和 IFormatProvider 接口来定义自定义格式提供程序，然后调用 String.Format(IFormatProvider, String, Object[]) 该方法。

以下示例定义一个 ComplexFormatter 类，该类以任 a + bi 一或 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 c1)
        {
            // Check if the format string has a precision specifier.
            int precision;
            string fmtString = string.Empty;
            if (format.Length > 1)
            {
                try
                {
                    precision = int.Parse(format.Substring(1));
                }
                catch (FormatException)
                {
                    precision = 0;
                }
                fmtString = "N" + precision.ToString();
            }
            if (format.Substring(0, 1).Equals("I", StringComparison.OrdinalIgnoreCase))
            {
                // Determine the sign to display.
                char sign = c1.Imaginary < 0 ? '-' : '+';
                // Display the determined sign and the absolute value of the imaginary part.
                return c1.Real.ToString(fmtString) + " " + sign + " " + Math.Abs(c1.Imaginary).ToString(fmtString) + "i";
            }
            else if (format.Substring(0, 1).Equals("J", StringComparison.OrdinalIgnoreCase))
            {
                // Determine the sign to display.
                char sign = c1.Imaginary < 0 ? '-' : '+';
                // Display the determined sign and the absolute value of the imaginary part.
                return c1.Real.ToString(fmtString) + " " + sign + " " + Math.Abs(c1.Imaginary).ToString(fmtString) + "j";
            }
            else
                return c1.ToString(format, provider);
        }
        else
        {
            if (arg is IFormattable formattable)
                return formattable.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 = Integer.Parse(fmt.Substring(1))
                Catch e As FormatException
                    precision = 0
                End Try
                fmtString = "N" + precision.ToString()
            End If
            ' Determine the sign to display.
            Dim sign As Char = If(c1.Imaginary < 0.0, "-"c, "+"c)
            ' Display the determined sign and the absolute value of the imaginary part.
            If fmt.Substring(0, 1).Equals("I", StringComparison.OrdinalIgnoreCase) Then
                Return c1.Real.ToString(fmtString) + " " + sign + " " + Math.Abs(c1.Imaginary).ToString(fmtString) + "i"
            ElseIf fmt.Substring(0, 1).Equals("J", StringComparison.OrdinalIgnoreCase) Then
                Return c1.Real.ToString(fmtString) + " " + sign + " " + Math.Abs(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

下面的示例随后使用此自定义格式化程序显示复数的字符串表示形式。

public class CustomFormatEx
{
    public static void Run()
    {
        Complex c1 = new(12.1, 15.4);
        Console.WriteLine($"Formatting with ToString:         {c1}");
        Console.WriteLine($"Formatting with ToString(format): {c1:N2}");
        Console.WriteLine($"Custom formatting with I0:\t" +
            $"  {string.Format(new ComplexFormatter(), "{0:I0}", c1)}");
        Console.WriteLine($"Custom formatting with J3:\t" +
            $"  {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 Example2
    Public Sub Run()
        Dim c1 As New Complex(12.1, 15.4)
        Console.WriteLine($"Formatting with ToString():       {c1}")
        Console.WriteLine($"Formatting with ToString(format): {c1: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

构造函数

名称	说明
Complex(Double, Double)	使用指定的真实值和虚值初始化结构的新实例 Complex 。

字段

名称	说明
ImaginaryOne	返回一个新 Complex 实例，其实数等于零，虚数等于 1。
Infinity	表示无穷大作为复数。
NaN	表示非数字（NaN）的复杂实例。
One	返回一个新 Complex 实例，其实数等于一个，虚数等于零。
Zero	返回一个新 Complex 实例，其实数等于零，虚数等于零。

属性

名称	说明
Imaginary	获取当前 Complex 对象的虚部。
Magnitude	获取复数的量级（或绝对值）。
Phase	获取复数的阶段。
Real	获取当前 Complex 对象的实际组件。

方法

名称	说明
Abs(Complex)	获取复数的绝对值（或数量级）。
Acos(Complex)	返回指定复数的弧余弦值的角度。
Add(Complex, Complex)	添加两个复数并返回结果。
Add(Complex, Double)	将复数添加到双精度实数并返回结果。
Add(Double, Complex)	将双精度实数添加到复数并返回结果。
Asin(Complex)	返回指定复数的弧正弦值的角度。
Atan(Complex)	返回指定复数的反正切值的角度。
Conjugate(Complex)	计算复数的串联并返回结果。
Cos(Complex)	返回指定复数的余弦值。
Cosh(Complex)	返回指定复数的双曲余弦值。
CreateChecked<TOther>(TOther)	从值创建当前类型的实例，为超出当前类型的可表示范围的任何值引发溢出异常。
CreateSaturating<TOther>(TOther)	从值创建当前类型的实例，使属于当前类型的可表示范围之外的任何值饱和。
CreateTruncating<TOther>(TOther)	从值创建当前类型的实例，截断属于当前类型的可表示范围之外的任何值。
Divide(Complex, Complex)	将一个复数除以另一个复数并返回结果。
Divide(Complex, Double)	将一个复数除以双精度实数并返回结果。
Divide(Double, Complex)	将一个双精度实数除以复数并返回结果。
Equals(Complex)	返回一个值，该值指示当前实例和指定的复数是否具有相同的值。
Equals(Object)	返回一个值，该值指示当前实例和指定对象是否具有相同的值。
Exp(Complex)	返回 `e` 由复数指定的幂。
FromPolarCoordinates(Double, Double)	从点的极坐标创建复数。
GetHashCode()	返回当前 Complex 对象的哈希代码。
IsComplexNumber(Complex)	确定值是否表示复杂值。
IsEvenInteger(Complex)	确定值是否表示偶数。
IsFinite(Complex)	确定指定的复数是否有限。
IsImaginaryNumber(Complex)	确定值是否表示虚数。
IsInfinity(Complex)	返回一个值，该值指示指定的复数是否计算为无穷大。
IsInteger(Complex)	确定值是否表示整型值。
IsNaN(Complex)	返回一个值，该值指示指定的复杂实例是否不是数字（NaN）。
IsNegative(Complex)	确定值是否为负值。
IsNegativeInfinity(Complex)	确定值是否为负无穷大。
IsNormal(Complex)	确定值是否正常。
IsOddInteger(Complex)	确定值是否表示奇数整数。
IsPositive(Complex)	确定值是否为正值。
IsPositiveInfinity(Complex)	确定值是否为正无穷大。
IsRealNumber(Complex)	确定值是否表示实数。
IsSubnormal(Complex)	确定某个值是否为非正常值。
Log(Complex, Double)	返回指定基数中指定复数的对数。
Log(Complex)	返回指定复数的自然（base `e`）对数。
Log10(Complex)	返回指定复数的 base-10 对数。
MaxMagnitude(Complex, Complex)	比较两个值与计算值更大。
MinMagnitude(Complex, Complex)	比较两个值与计算值较小。
Multiply(Complex, Complex)	返回两个复数的乘积。
Multiply(Complex, Double)	返回复数和双精度实数的乘积。
Multiply(Double, Complex)	返回双精度实数和复数的乘积。
Negate(Complex)	返回指定复数的累加反函数。
Parse(ReadOnlySpan<Byte>, IFormatProvider)	表示复数。
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	表示复数。
Parse(ReadOnlySpan<Char>, IFormatProvider)	将字符的范围分析为值。
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	将字符的范围分析为值。
Parse(String, IFormatProvider)	将字符串分析为值。
Parse(String, NumberStyles, IFormatProvider)	将字符串分析为值。
Pow(Complex, Complex)	返回由复数指定的幂引发的指定复数。
Pow(Complex, Double)	返回由双精度浮点数指定的幂的指定复数。
Reciprocal(Complex)	返回复数的乘法反数。
Sin(Complex)	返回指定复数的正弦值。
Sinh(Complex)	返回指定复数的双曲正弦值。
Sqrt(Complex)	返回指定复数的平方根。
Subtract(Complex, Complex)	从另一个复数中减去一个复数并返回结果。
Subtract(Complex, Double)	从复数中减去一个双精度实数并返回结果。
Subtract(Double, Complex)	从双精度实数中减去一个复数并返回结果。
Tan(Complex)	返回指定复数的正切值。
Tanh(Complex)	返回指定复数的双曲正切值。
ToString()	将当前复数的值转换为其等效的字符串表示形式（以笛卡尔形式）。
ToString(IFormatProvider)	使用指定的区域性特定的格式设置信息，将当前复数的值转换为其以笛卡尔形式表示的等效字符串表示形式。
ToString(String, IFormatProvider)	使用指定格式和区域性特定的格式信息，将当前复数的值转换为其以笛卡尔形式表示的等效字符串表示形式，以实际部分和虚构部分。
ToString(String)	将当前复数的值转换为其以笛卡尔形式表示的等效字符串表示形式，方法是使用指定格式作为其真实和虚部。
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	尝试将当前实例的值格式化为 UTF-8，并将其设置为提供的字节范围。
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	尝试将当前实例的值格式化为提供的字符范围。
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Complex)	表示复数。
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Complex)	表示复数。
TryParse(ReadOnlySpan<Char>, IFormatProvider, Complex)	尝试将字符范围分析为值。
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Complex)	尝试将字符范围分析为值。
TryParse(String, IFormatProvider, Complex)	尝试将字符串分析为值。
TryParse(String, NumberStyles, IFormatProvider, Complex)	尝试将字符串分析为值。

运营商

名称	说明
Addition(Complex, Complex)	添加两个复数。
Addition(Complex, Double)	向双精度实数添加复数。
Addition(Double, Complex)	将双精度实数添加到复数。
Decrement(Complex)	递减值。
Division(Complex, Complex)	将指定的复数除以另一个指定的复数。
Division(Complex, Double)	将指定的复数除以指定的双精度实数。
Division(Double, Complex)	将指定的双精度实数除以指定的复数。
Equality(Complex, Complex)	返回一个值，该值指示两个复数是否相等。
Explicit(BigInteger to Complex)	定义值到复数的 BigInteger 显式转换。
Explicit(Decimal to Complex)	定义值到复数的 Decimal 显式转换。
Explicit(Int128 to Complex)	显式将值 Int128 转换为双精度复数。
Explicit(UInt128 to Complex)	显式将值 UInt128 转换为双精度复数。
Implicit(BFloat16 to Complex)	表示复数。
Implicit(Byte to Complex)	定义将无符号字节隐式转换为复数。
Implicit(Char to Complex)	隐式将值 Char 转换为双精度复数。
Implicit(Double to Complex)	定义双精度浮点数到复数的隐式转换。
Implicit(Half to Complex)	隐式将值 Half 转换为双精度复数。
Implicit(Int16 to Complex)	定义 16 位有符号整数到复数的隐式转换。
Implicit(Int32 to Complex)	定义 32 位有符号整数到复数的隐式转换。
Implicit(Int64 to Complex)	定义 64 位有符号整数到复数的隐式转换。
Implicit(IntPtr to Complex)	隐式将值 IntPtr 转换为双精度复数。
Implicit(SByte to Complex)	定义已签名字节到复数的隐式转换。此 API 不符合 CLS。
Implicit(Single to Complex)	定义单精度浮点数到复数的隐式转换。
Implicit(UInt16 to Complex)	定义 16 位无符号整数到复数的隐式转换。此 API 不符合 CLS。
Implicit(UInt32 to Complex)	定义 32 位无符号整数到复数的隐式转换。此 API 不符合 CLS。
Implicit(UInt64 to Complex)	定义 64 位无符号整数到复数的隐式转换。此 API 不符合 CLS。
Implicit(UIntPtr to Complex)	隐式将值 UIntPtr 转换为双精度复数。
Increment(Complex)	递增值。
Inequality(Complex, Complex)	返回一个值，该值指示两个复数是否不相等。
Multiply(Complex, Complex)	将两个指定的复数相乘。
Multiply(Complex, Double)	将指定的复数乘以指定的双精度实数。
Multiply(Double, Complex)	将指定的双精度实数乘以指定的复数。
Subtraction(Complex, Complex)	从另一个复数中减去复数。
Subtraction(Complex, Double)	从复数中减去双精度实数。
Subtraction(Double, Complex)	从双精度实数中减去复数。
UnaryNegation(Complex)	返回指定复数的累加反函数。
UnaryPlus(Complex)	计算一元加值。

显式接口实现

名称	说明
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)	将两个值与计算进行比较，如果输入 `NaN`是，则返回另一个值。
INumberBase<Complex>.MinMagnitudeNumber(Complex, Complex)	将两个值与计算进行比较，如果输入 `NaN`是，则返回另一个值。
INumberBase<Complex>.MultiplyAddEstimate(Complex, Complex, Complex)	计算（`left` * `right`） + `addend`的估计值。
INumberBase<Complex>.One	获取类型 `1` 的值。
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	获取类型 `0` 的值。
ISignedNumber<Complex>.NegativeOne	获取类型 `-1` 的值。

适用于

反馈

此页面是否有帮助？