Complex Struktura

Definice

Představuje komplexní číslo.Represents a complex number.

public value class Complex : IEquatable<System::Numerics::Complex>, IFormattable
[System.Serializable]
public struct Complex : IEquatable<System.Numerics.Complex>, IFormattable
type Complex = struct
    interface IFormattable
Public Structure Complex
Implements IEquatable(Of Complex), IFormattable
Dědičnost
Complex
Atributy
Implementuje

Poznámky

Komplexní číslo je číslo, které zahrnuje část reálného čísla a imaginární část čísla.A complex number is a number that comprises a real number part and an imaginary number part. Komplexní číslo z je obvykle napsáno ve tvaru z = x + yi, kde x a y jsou reálné hodnoty a i je imaginární jednotka, která má vlastnost i2 =-1.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 i2 = -1. Reálná část komplexního čísla je reprezentována xa imaginární část komplexního čísla je reprezentována y.The real part of the complex number is represented by x, and the imaginary part of the complex number is represented by y.

Complex Typ používá systém souřadnic kartézském (Real, imaginární část) při vytváření instancí a manipulaci se složitými čísly.The Complex type uses the Cartesian coordinate system (real, imaginary) when instantiating and manipulating complex numbers. Komplexní číslo může být reprezentované jako bod v dvojrozměrném systému souřadnic, který se označuje jako složitá rovina.A complex number can be represented as a point in a two-dimensional coordinate system, which is known as the complex plane. Skutečná část komplexního čísla je umístěna na ose x (vodorovná osa) a imaginární část je umístěna na ose y (svislá osa).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).

Libovolný bod v komplexní rovině lze také vyjádřit na základě jeho absolutní hodnoty, a to pomocí polárního souřadnicového systému.Any point in the complex plane can also be expressed based on its absolute value, by using the polar coordinate system. V polárních souřadnicích je bod charakterizován dvěma čísly:In polar coordinates, a point is characterized by two numbers:

  • Jeho velikost, což je vzdálenost bodu od počátku (tj. 0, 0, nebo bod, ve kterém se protínají osa x a osa y).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).

  • Její fáze, což je úhel mezi skutečnou osou a řádkem nakresleným od počátku až k bodu.Its phase, which is the angle between the real axis and the line drawn from the origin to the point.

Vytvoření instance komplexního číslaInstantiating a Complex Number

Komplexnímu číslu můžete přiřadit hodnotu jedním z následujících způsobů:You can assign a value to a complex number in one of the following ways:

  • Předáním dvou Double hodnot do konstruktoru.By passing two Double values to its constructor. První hodnota představuje skutečnou část komplexního čísla a druhá hodnota představuje její imaginární část.The first value represents the real part of the complex number, and the second value represents its imaginary part. Tyto hodnoty reprezentují umístění komplexního čísla v dvojrozměrném systémovém souřadnici kartézském.These values represent the position of the complex number in the two-dimensional Cartesian coordinate system.

  • Voláním statické metody (Shared v Visual Basic) Complex.FromPolarCoordinates pro vytvoření komplexního čísla z jeho polárních souřadnic.By calling the static (Shared in Visual Basic) Complex.FromPolarCoordinates method to create a complex number from its polar coordinates.

  • Přiřazením Bytehodnoty, SByte, Int16, UInt16 ,,UInt64, ,Int64 ,Complex nebo sobjektem.Single Int32 UInt32 DoubleBy assigning a Byte, SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, Single, or Double value to a Complex object. Hodnota se stávají skutečnou částí komplexního čísla a její imaginární část je rovna 0.The value becomes the real part of the complex number, and its imaginary part equals 0.

  • Přetypováním ( C#v) nebo převodem (v Visual Basic Decimal ) BigInteger hodnoty Complex nebo na objekt.By casting (in C#) or converting (in Visual Basic) a Decimal or BigInteger value to a Complex object. Hodnota se stávají skutečnou částí komplexního čísla a její imaginární část je rovna 0.The value becomes the real part of the complex number, and its imaginary part equals 0.

  • Přiřazením komplexního čísla, které je vráceno metodou nebo operátorem Complex objektu.By assigning the complex number that is returned by a method or operator to a Complex object. Například Complex.Add je statická metoda, která vrací komplexní číslo, které je součtem dvou komplexních čísel, Complex.Addition a operátor přidá dvě složitá čísla a vrátí výsledek.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.

Následující příklad znázorňuje každé z těchto pěti způsobů přiřazení hodnoty ke komplexnímu číslu.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)

Operace s komplexními číslyOperations with Complex Numbers

Complex Struktura v .NET Framework zahrnuje členy, které poskytují následující funkce:The Complex structure in the .NET Framework includes members that provide the following functionality:

  • Metody pro porovnání dvou složitých čísel, aby bylo možné určit, zda jsou stejné.Methods to compare two complex numbers to determine whether they are equal.

  • Operátory k provádění aritmetických operací na komplexních číslech.Operators to perform arithmetic operations on complex numbers. Complexoperátory umožňují provádět sčítání, odčítání, násobení, dělení a unární negaci se složitými čísly.Complex operators enable you to perform addition, subtraction, multiplication, division, and unary negation with complex numbers.

  • Metody pro provádění dalších číselných operací na komplexních číslech.Methods to perform other numerical operations on complex numbers. Kromě čtyř základních aritmetických operací můžete pro zadanou mocninu vytvořit komplexní číslo, najít druhou odmocninu komplexního čísla a získat absolutní hodnotu komplexního čísla.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.

  • Metody pro provádění trigonometrických operací na komplexních číslech.Methods to perform trigonometric operations on complex numbers. Můžete například vypočítat tangens úhlu reprezentovaného komplexním číslem.For example, you can calculate the tangent of an angle represented by a complex number.

Všimněte si, že vzhledem Real k Imaginary tomu, že vlastnosti a jsou jen pro čtení, nemůžete změnit Complex hodnotu existujícího objektu.Note that, because the Real and Imaginary properties are read-only, you cannot modify the value of an existing Complex object. Všechny metody, které provádějí operaci na Complex číslo, pokud je jejich návratová hodnota typu Complex, vrátí nové Complex číslo.All methods that perform an operation on a Complex number, if their return value is of type Complex, return a new Complex number.

Přesnost a komplexní číslaPrecision and Complex Numbers

Reálné a imaginární části komplexního čísla jsou reprezentovány dvěma hodnotami s plovoucí desetinnou čárkou a dvojitou přesností.The real and imaginary parts of a complex number are represented by two double-precision floating-point values. To znamená, Complex že hodnoty, jako například hodnoty s plovoucí desetinnou čárkou s dvojitou přesností, mohou způsobit ztrátu přesnosti v důsledku číselných operací.This means that Complex values, like double-precision floating-point values, can lose precision as a result of numerical operations. To znamená, že striktní porovnání rovnosti dvou Complex hodnot může selhat, i když rozdíl mezi těmito dvěma hodnotami je způsoben ztrátou přesnosti.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. Další informace naleznete v tématu Double.For more information, see Double.

Například provádění umocnění na logaritmu čísla by mělo vracet původní číslo.For example, performing exponentiation on the logarithm of a number should return the original number. V některých případech však ztráta přesnosti hodnot s plovoucí desetinnou čárkou může způsobit mírné rozdíly mezi dvěma hodnotami, jak ukazuje následující příklad.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

Podobně následující příklad, který vypočítá druhou Complex odmocninu čísla, vytvoří mírně odlišné výsledky v 32 a ia64 verzích .NET Framework.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.

Komplexní čísla, nekonečno a NaNComplex Numbers, Infinity, and NaN

Reálné a imaginární části komplexního čísla jsou reprezentovány Double hodnotami.The real and imaginary parts of a complex number are represented by Double values. Kromě Double.MinValue Double.PositiveInfinity Double.NegativeInfinity Double.NaNtoho, že reálné nebo imaginární část komplexního čísla může mít hodnotu, nebo. Double.MaxValueIn 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 aDouble.NaN všechny se šíří v jakékoli aritmetické nebo trigonometrické operaci.Double.PositiveInfinity, Double.NegativeInfinity, and Double.NaN all propagate in any arithmetic or trigonometric operation.

V následujícím příkladu dělení Zero vytvoří komplexní číslo, jehož reálné a imaginární části jsou obě. Double.NaNIn the following example, division by Zero produces a complex number whose real and imaginary parts are both Double.NaN. Výsledkem je, že provádění násobení s touto hodnotou také vytvoří komplexní číslo, jehož reálné a imaginární části jsou Double.NaN.As a result, performing multiplication with this value also produces a complex number whose real and imaginary parts are Double.NaN. Podobně provedení násobení, které přetéká rozsah Double typu, vytvoří komplexní číslo, jehož skutečná část je Double.NaN a jehož imaginární část je Double.PositiveInfinity.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. Následně dělení s tímto komplexním číslem vrátí komplexní číslo, jehož skutečná část je Double.NaN a jehož imaginární část je. Double.PositiveInfinitySubsequently 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)

Matematické operace se složitými čísly, které jsou neplatné nebo přetečení rozsahu Double datového typu, nevyvolají výjimku.Mathematical operations with complex numbers that are invalid or that overflow the range of the Double data type do not throw an exception. Místo toho vrátí Double.PositiveInfinity, Double.NegativeInfinitynebo Double.NaN za následujících podmínek:Instead, they return a Double.PositiveInfinity, Double.NegativeInfinity, or Double.NaN under the following conditions:

Všimněte si, že to platí pro všechny mezilehlé výpočty prováděné metodou.Note that this applies to any intermediate calculations performed by a method. Například násobení new Complex(9e308, 9e308) and new Complex(2.5, 3.5) používá vzorec (AC-BD) + (AD + BC) i.For example, the multiplication of new Complex(9e308, 9e308) and new Complex(2.5, 3.5) uses the formula (ac - bd) + (ad + bc)i. Výpočet reálné komponenty, která je výsledkem násobení, vyhodnocuje výraz 9e308 * 2,5-9e308 * 3,5.The calculation of the real component that results from the multiplication evaluates the expression 9e308 * 2.5 - 9e308 * 3.5. Každé mezilehlé násobení v tomto výrazu vrací Double.PositiveInfinitya pokus o odečtení Double.PositiveInfinity od Double.PositiveInfinity vrácení Double.NaN.Each intermediate multiplication in this expression returns Double.PositiveInfinity, and the attempt to subtract Double.PositiveInfinity from Double.PositiveInfinity returns Double.NaN.

Formátování komplexního číslaFormatting a Complex Number

Ve výchozím nastavení má řetězcová reprezentace složeného čísla **)formu reálného , formátu (, kde reálné a imaginární jsou řetězcové Double reprezentace hodnoty, které tvoří reálné a imaginární komponenty komplexního čísla.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. Některá přetížení ToString metody umožňují přizpůsobit řetězcové reprezentace těchto Double hodnot, aby odrážely konvence formátování konkrétní jazykové verze nebo aby se zobrazily v konkrétním formátu definovaném standardním nebo vlastním číselným číslem. řetězec formátuSome 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. (Další informace naleznete v tématu Standardní číselné formátovací řetězce a Vlastní řetězce číselného formátu.)(For more information, see Standard Numeric Format Strings and Custom Numeric Format Strings.)

Jedním z nejběžnějších způsobů, jak vyjádřit řetězcovou reprezentaci komplexního čísla, je mít formu a + BI, kde je skutečná součást komplexního čísla a b je imaginární část komplexního čísla.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. V elektrických technikách je složité číslo nejčastěji vyjádřeno jako + BJ.In electrical engineering, a complex number is most commonly expressed as a + bj. V obou těchto dvou formách můžete vracet řetězcové vyjádření komplexního čísla.You can return the string representation of a complex number in either of these two forms. To uděláte tak, že definujete poskytovatele vlastního formátu implementací ICustomFormatter rozhraní IFormatProvider a a pak zavoláte String.Format(IFormatProvider, String, Object[]) metodu.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.

Následující příklad definuje ComplexFormatter třídu, která představuje komplexní číslo jako řetězec ve formátu buď a + bi nebo + BJ.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

Následující příklad poté používá tento vlastní formátovací modul pro zobrazení řetězcové reprezentace komplexního čísla.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

Konstruktory

Complex(Double, Double)

Inicializuje novou instanci Complex struktury pomocí zadaných reálných a imaginárních hodnot.Initializes a new instance of the Complex structure using the specified real and imaginary values.

Pole

ImaginaryOne

Vrátí novou Complex instanci se skutečným číslem, který se rovná nule a imaginární číslo se rovná jedné.Returns a new Complex instance with a real number equal to zero and an imaginary number equal to one.

Infinity

Představuje nekonečno jako komplexní číslo.Represents infinity as a complex number.

NaN

Představuje komplexní instanci, která není číslo (NaN).Represents a complex instance that is not a number (NaN).

One

Vrátí novou Complex instanci se skutečným číslem, který se rovná jedné a imaginární číslo se rovná nule.Returns a new Complex instance with a real number equal to one and an imaginary number equal to zero.

Zero

Vrátí novou Complex instanci se skutečným číslem, který se rovná nule a imaginární číslo se rovná nule.Returns a new Complex instance with a real number equal to zero and an imaginary number equal to zero.

Vlastnosti

Imaginary

Získá imaginární komponentu aktuálního Complex objektu.Gets the imaginary component of the current Complex object.

Magnitude

Získá velikost (nebo absolutní hodnotu) komplexního čísla.Gets the magnitude (or absolute value) of a complex number.

Phase

Získá fázi komplexního čísla.Gets the phase of a complex number.

Real

Získá skutečnou komponentu aktuálního Complex objektu.Gets the real component of the current Complex object.

Metody

Abs(Complex)

Získá absolutní hodnotu (nebo velikost) komplexního čísla.Gets the absolute value (or magnitude) of a complex number.

Acos(Complex)

Vrátí úhel, který je kosinus zadaného komplexního čísla.Returns the angle that is the arc cosine of the specified complex number.

Add(Complex, Complex)

Přidá dvě komplexní čísla a vrátí výsledek.Adds two complex numbers and returns the result.

Add(Complex, Double)

Přidá komplexní číslo do reálného čísla s dvojitou přesností a vrátí výsledek.Adds a complex number to a double-precision real number and returns the result.

Add(Double, Complex)

Přidá reálné číslo s dvojitou přesností na komplexní číslo a vrátí výsledek.Adds a double-precision real number to a complex number and returns the result.

Asin(Complex)

Vrátí úhel, který je sinusem oblouku zadaného komplexního čísla.Returns the angle that is the arc sine of the specified complex number.

Atan(Complex)

Vrátí úhel, který je obloukové tečnou zadaného komplexního čísla.Returns the angle that is the arc tangent of the specified complex number.

Conjugate(Complex)

Vypočítá sdružený složený z komplexního čísla a vrátí výsledek.Computes the conjugate of a complex number and returns the result.

Cos(Complex)

Vrátí kosinus zadaného komplexního čísla.Returns the cosine of the specified complex number.

Cosh(Complex)

Vrací hyperbolický kosinus zadaného komplexního čísla.Returns the hyperbolic cosine of the specified complex number.

Divide(Complex, Complex)

Vydělí jedno komplexní číslo jiným a vrátí výsledek.Divides one complex number by another and returns the result.

Divide(Complex, Double)

Vydělí jedno komplexní číslo pomocí reálného čísla dvojitou přesnost a vrátí výsledek.Divides one complex number by a double-precision real number and returns the result.

Divide(Double, Complex)

Vydělí jedno reálné číslo s dvojitou přesností komplexním číslem a vrátí výsledek.Divides one double-precision real number by a complex number and returns the result.

Equals(Complex)

Vrátí hodnotu, která označuje, zda aktuální instance a zadané komplexní číslo mají stejnou hodnotu.Returns a value that indicates whether the current instance and a specified complex number have the same value.

Equals(Object)

Vrátí hodnotu, která označuje, zda aktuální instance a zadaný objekt mají stejnou hodnotu.Returns a value that indicates whether the current instance and a specified object have the same value.

Exp(Complex)

Vrátí e hodnotu vyvolanou pro napájení určenou komplexním číslem.Returns e raised to the power specified by a complex number.

FromPolarCoordinates(Double, Double)

Vytvoří komplexní číslo z polárních souřadnic bodu.Creates a complex number from a point's polar coordinates.

GetHashCode()

Vrátí hodnotu hash aktuálního Complex objektu.Returns the hash code for the current Complex object.

IsFinite(Complex)

Určuje, zda je zadané komplexní číslo omezené.Determines whether the specified complex number is finite.

IsInfinity(Complex)

Vrátí hodnotu, která označuje, zda je zadané komplexní číslo vyhodnoceno jako nekonečno.Returns a value indicating whether the specified complex number evaluates to infinity.

IsNaN(Complex)

Vrátí hodnotu, která označuje, zda zadaná komplexní instance není číslo (NaN).Returns a value that indicates whether the specified complex instance is not a number (NaN).

Log(Complex)

Vrátí přirozený (základní e) logaritmus zadaného komplexního čísla.Returns the natural (base e) logarithm of a specified complex number.

Log(Complex, Double)

Vrátí logaritmus zadaného komplexního čísla v zadaném základu.Returns the logarithm of a specified complex number in a specified base.

Log10(Complex)

Vrátí logaritmus o základu 10 zadaného komplexního čísla.Returns the base-10 logarithm of a specified complex number.

Multiply(Complex, Complex)

Vrátí součin dvou komplexních čísel.Returns the product of two complex numbers.

Multiply(Complex, Double)

Vrátí součin komplexního čísla a reálné číslo s dvojitou přesností.Returns the product of a complex number and a double-precision real number.

Multiply(Double, Complex)

Vrátí součin reálného čísla s dvojitou přesností a komplexní číslo.Returns the product of a double-precision real number and a complex number.

Negate(Complex)

Vrátí doplňkovou hodnotu INVERT zadaného komplexního čísla.Returns the additive inverse of a specified complex number.

Pow(Complex, Complex)

Vrátí zadané komplexní číslo umocněné na napájení určené komplexním číslem.Returns a specified complex number raised to a power specified by a complex number.

Pow(Complex, Double)

Vrátí zadané komplexní číslo umocněné na mocninu určenou číslem s plovoucí desetinnou čárkou a dvojitou přesností.Returns a specified complex number raised to a power specified by a double-precision floating-point number.

Reciprocal(Complex)

Vrátí multiplikativní inverzního čísla ke komplexnímu číslu.Returns the multiplicative inverse of a complex number.

Sin(Complex)

Vrátí sinus zadaného komplexního čísla.Returns the sine of the specified complex number.

Sinh(Complex)

Vrací hyperbolický sinus zadaného komplexního čísla.Returns the hyperbolic sine of the specified complex number.

Sqrt(Complex)

Vrátí druhou odmocninu zadaného komplexního čísla.Returns the square root of a specified complex number.

Subtract(Complex, Complex)

Odečte jedno komplexní číslo od druhého a vrátí výsledek.Subtracts one complex number from another and returns the result.

Subtract(Complex, Double)

Odečte jedno reálné číslo s dvojitou přesností ze složeného čísla a vrátí výsledek.Subtracts one double-precision real number from a complex number and returns the result.

Subtract(Double, Complex)

Odečte jedno komplexní číslo od reálného čísla s dvojitou přesností a vrátí výsledek.Subtracts one complex number from a double-precision real number and returns the result.

Tan(Complex)

Vrací tangens zadaného komplexního čísla.Returns the tangent of the specified complex number.

Tanh(Complex)

Vrací hyperbolický tangens zadaného komplexního čísla.Returns the hyperbolic tangent of the specified complex number.

ToString()

Převede hodnotu aktuálního komplexního čísla na odpovídající řetězcovou reprezentaci ve formátu kartézském.Converts the value of the current complex number to its equivalent string representation in Cartesian form.

ToString(IFormatProvider)

Převede hodnotu aktuálního komplexního čísla na odpovídající řetězcovou reprezentaci v kartézském formuláři pomocí zadaných informací o formátování specifické pro jazykovou verzi.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)

Převede hodnotu aktuálního komplexního čísla na odpovídající řetězcovou reprezentaci v kartézském formuláři pomocí zadaného formátu pro své reálné a imaginární části.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)

Převede hodnotu aktuálního komplexního čísla na odpovídající řetězcovou reprezentaci ve formuláři kartézském pomocí zadaného formátu a informací o formátování specifické jazykové verze pro své reálné a imaginární části.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.

Operátory

Addition(Complex, Complex)

Přidá dvě složitá čísla.Adds two complex numbers.

Addition(Complex, Double)

Přidá komplexní číslo do reálného čísla s dvojitou přesností.Adds a complex number to a double-precision real number.

Addition(Double, Complex)

Přidá reálné číslo s dvojitou přesností na komplexní číslo.Adds a double-precision real number to a complex number.

Division(Complex, Complex)

Vydělí zadané komplexní číslo jiným zadaným komplexním číslem.Divides a specified complex number by another specified complex number.

Division(Complex, Double)

Vydělí zadané komplexní číslo zadaným reálnému číslu s dvojitou přesností.Divides a specified complex number by a specified double-precision real number.

Division(Double, Complex)

Vydělí zadané reálné číslo s dvojitou přesností zadaným komplexním číslem.Divides a specified double-precision real number by a specified complex number.

Equality(Complex, Complex)

Vrátí hodnotu, která označuje, zda jsou dvě složitá čísla shodná.Returns a value that indicates whether two complex numbers are equal.

Explicit(BigInteger to Complex)

Definuje explicitní převod BigInteger hodnoty na komplexní číslo.Defines an explicit conversion of a BigInteger value to a complex number.

Explicit(Decimal to Complex)

Definuje explicitní převod Decimal hodnoty na komplexní číslo.Defines an explicit conversion of a Decimal value to a complex number.

Implicit(Byte to Complex)

Definuje implicitní převod bajt bez znaménka na komplexní číslo.Defines an implicit conversion of an unsigned byte to a complex number.

Implicit(Double to Complex)

Definuje implicitní převod čísla s plovoucí desetinnou čárkou a dvojitou přesností na komplexní číslo.Defines an implicit conversion of a double-precision floating-point number to a complex number.

Implicit(Int16 to Complex)

Definuje implicitní převod 16bitového celého čísla se znaménkem na komplexní číslo.Defines an implicit conversion of a 16-bit signed integer to a complex number.

Implicit(Int32 to Complex)

Definuje implicitní převod celého čísla se znaménkem (32) na komplexní číslo.Defines an implicit conversion of a 32-bit signed integer to a complex number.

Implicit(Int64 to Complex)

Definuje implicitní převod celého čísla se znaménkem (64) na komplexní číslo.Defines an implicit conversion of a 64-bit signed integer to a complex number.

Implicit(SByte to Complex)

Definuje implicitní převod podepsaného bajtu na komplexní číslo.Defines an implicit conversion of a signed byte to a complex number.

Toto rozhraní API není kompatibilní se specifikací CLS.This API is not CLS-compliant.

Implicit(Single to Complex)

Definuje implicitní převod čísla s plovoucí desetinnou čárkou s jednoduchou přesností na komplexní číslo.Defines an implicit conversion of a single-precision floating-point number to a complex number.

Implicit(UInt16 to Complex)

Definuje implicitní převod 16bitového unsigned integer na komplexní číslo.Defines an implicit conversion of a 16-bit unsigned integer to a complex number.

Toto rozhraní API není kompatibilní se specifikací CLS.This API is not CLS-compliant.

Implicit(UInt32 to Complex)

Definuje implicitní převod 32 unsigned integer na komplexní číslo.Defines an implicit conversion of a 32-bit unsigned integer to a complex number.

Toto rozhraní API není kompatibilní se specifikací CLS.This API is not CLS-compliant.

Implicit(UInt64 to Complex)

Definuje implicitní převod 64 unsigned integer na komplexní číslo.Defines an implicit conversion of a 64-bit unsigned integer to a complex number.

Toto rozhraní API není kompatibilní se specifikací CLS.This API is not CLS-compliant.

Inequality(Complex, Complex)

Vrátí hodnotu, která označuje, zda nejsou dvě složitá čísla shodná.Returns a value that indicates whether two complex numbers are not equal.

Multiply(Complex, Complex)

Vynásobí dvě zadaná komplexní čísla.Multiplies two specified complex numbers.

Multiply(Complex, Double)

Vynásobí zadané komplexní číslo zadaným reálného čísla s dvojitou přesností.Multiplies the specified complex number by a specified double-precision real number.

Multiply(Double, Complex)

Vynásobí zadané reálné číslo s dvojitou přesností zadaným komplexním číslem.Multiplies a specified double-precision real number by a specified complex number.

Subtraction(Complex, Complex)

Odečte komplexní číslo od jiného komplexního čísla.Subtracts a complex number from another complex number.

Subtraction(Complex, Double)

Odečte reálné číslo s dvojitou přesností ze složeného čísla.Subtracts a double-precision real number from a complex number.

Subtraction(Double, Complex)

Odečte komplexní číslo od reálného čísla s dvojitou přesností.Subtracts a complex number from a double-precision real number.

UnaryNegation(Complex)

Vrátí doplňkovou hodnotu INVERT zadaného komplexního čísla.Returns the additive inverse of a specified complex number.

Platí pro