System.Numerics.Complex – struktura
Tento článek obsahuje doplňující poznámky k referenční dokumentaci pro toto rozhraní API.
Komplexní číslo je číslo, které zahrnuje reálnou číselnou část a imaginární číselnou část. Komplexní číslo z je obvykle zapsáno ve formě z = x + yi, kde x a y jsou reálná čísla, a i je imaginární jednotka, která má vlastnost i2 = -1. Reálnou část komplexního čísla představuje x a imaginární část komplexního čísla je reprezentována y.
Typ Complex používá kartézský souřadnicový systém (skutečný, imaginární) při vytváření instancí a manipulaci se složitými čísly. Komplexní číslo může být reprezentováno jako bod v dvojrozměrném souřadnicovém systému, který se označuje jako komplexní rovina. Skutečná část komplexního čísla je umístěná na ose x (vodorovná osa) a imaginární část je umístěná na ose y (svislá osa).
Libovolný bod v komplexní rovině lze také vyjádřit na základě své absolutní hodnoty pomocí polárního souřadnicového systému. V polárních souřadnicích je bod charakterizován dvěma čísly:
- Jeho velikost, což je vzdálenost bodu od počátku (to znamená 0,0 nebo bod, ve kterém se protíná osa x a osa y).
- Jeho fáze, což je úhel mezi skutečnou osou a přímkou nakreslenou z počátku do bodu.
Vytvoření instance komplexního čísla
Hodnotu ke komplexnímu číslu můžete přiřadit jedním z následujících způsobů:
Předáním dvou Double hodnot konstruktoru První hodnota představuje skutečnou část komplexního čísla a druhá hodnota představuje její imaginární část. Tyto hodnoty představují pozici komplexního čísla v dvojrozměrném kartézském souřadnicovém systému.
Voláním statické metody (
Sharedv jazyce Visual Basic) Complex.FromPolarCoordinates vytvoříte komplexní číslo z jeho polárních souřadnic.Přiřazením , , , UInt32Int32Int16UInt16Int64, UInt64, Singlenebo Double hodnoty objektu.Complex SByteByte Hodnota se stane skutečnou částí komplexního čísla a její imaginární část se rovná 0.
Přetypováním (v jazyce C#) nebo převodem Decimal (v jazyce Visual Basic) na objekt nebo BigInteger hodnotu Complex . Hodnota se stane skutečnou částí komplexního čísla a její imaginární část se rovná 0.
Přiřazením komplexního čísla vráceného metodou nebo operátorem k objektu Complex . Je to například Complex.Add statická metoda, která vrátí komplexní číslo, které je součtem dvou komplexních čísel, a Complex.Addition operátor sčítá dvě komplexní čísla a vrátí výsledek.
Následující příklad ukazuje každý z těchto pěti způsobů přiřazení hodnoty ke komplexnímu číslu.
using System;
using System.Numerics;
public class CreateEx
{
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 se složitými čísly
Struktura Complex v .NET zahrnuje členy, které poskytují následující funkce:
- Metody porovnání dvou komplexních čísel k určení, zda jsou rovny.
- Operátory pro provádění aritmetických operací s komplexními čísly Complex Operá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.
- Metody pro provádění dalších numerických operací se složitými čísly Kromě čtyř základních aritmetických operací můžete zvýšit komplexní číslo na zadanou mocninu, najít druhou odmocninu komplexního čísla a získat absolutní hodnotu komplexního čísla.
- Metody provádění trigonometrických operací se složitými čísly Můžete například vypočítat tangens úhlu reprezentované komplexním číslem.
Všimněte si, že vzhledem k tomu, že vlastnosti Real jsou Imaginary jen pro čtení, nelze upravit hodnotu existujícího Complex objektu. Všechny metody, které provádějí operaci s číslem Complex , pokud je jejich návratová hodnota typu Complex, vrátí nové Complex číslo.
Přesnost a komplexní čísla
Skutečné a imaginární části komplexního čísla jsou reprezentovány dvěma hodnotami s plovoucí desetinnou čárkou s dvojitou přesností. To znamená, že Complex hodnoty, jako jsou hodnoty s plovoucí desetinnou čárkou s dvojitou přesností, mohou v důsledku číselných operací ztratit přesnost. To znamená, že přísné porovnání rovnosti dvou Complex hodnot může selhat, i když je rozdíl mezi těmito dvěma hodnotami způsobený ztrátou přesnosti. Další informace najdete na webu Double.
Například při exponentaci logaritmu čísla by se mělo vrátit původní číslo. V některých případech však může ztráta přesnosti hodnot s plovoucí desetinnou čárkou způsobit mírné rozdíly mezi těmito dvěma hodnotami, jak ukazuje následující příklad.
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 odmocninu Complex čísla, produkuje mírně odlišné výsledky na 32bitové a IA64 verze .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.
Nekonečno a NaN
Skutečné a imaginární části komplexního čísla jsou reprezentovány Double hodnotami. Kromě rozsahu od Double.MinValue do Double.MaxValue, reálná nebo imaginární část komplexního čísla může mít hodnotu Double.PositiveInfinity, Double.NegativeInfinitynebo Double.NaN. Double.PositiveInfinity, Double.NegativeInfinitya Double.NaN všechny šíření v jakékoli aritmetické nebo trigonometrické operaci.
V následujícím příkladu dělení vytvoří Zero komplexní číslo, jehož skutečné a imaginární části jsou oba Double.NaN. Výsledkem je, že provádění násobení s touto hodnotou také vytvoří komplexní číslo, jehož skutečné a imaginární části jsou Double.NaN. Podobně provedení násobení, které přeteče rozsah Double typu vytvoří komplexní číslo, jehož reálnou částí je Double.NaN a jehož imaginární část je Double.PositiveInfinity. Následné dělení s tímto komplexním číslem vrátí komplexní číslo, jehož reálnou částí je Double.NaN a jehož imaginární částí je Double.PositiveInfinity.
using System;
using System.Numerics;
public class NaNEx
{
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 Example4
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 které přetékají oblast datového Double typu, nevyvolají výjimku. Místo toho vrátí Double.PositiveInfinityznak , Double.NegativeInfinitynebo Double.NaN za následujících podmínek:
- Dělení kladného čísla nulou vrátí Double.PositiveInfinity.
- Jakákoli operace, která přeteče horní mez datového Double typu, vrátí Double.PositiveInfinity.
- Dělení záporného čísla nulou vrátí Double.NegativeInfinity.
- Jakákoli operace, která přeteče dolní mez datového Double typu, vrátí Double.NegativeInfinity.
- Dělení nuly o nulu vrátí Double.NaN.
- Jakákoli operace prováděná na operandech, jejichž hodnoty jsou Double.PositiveInfinity, Double.NegativeInfinitynebo Double.NaN vrací Double.PositiveInfinity, Double.NegativeInfinitynebo Double.NaNv závislosti na konkrétní operaci.
Všimněte si, že to platí pro všechny přechodné výpočty prováděné metodou. Například násobení new Complex(9e308, 9e308) and new Complex(2.5, 3.5) používá vzorec (ac - bd) + (ad + bc)i. Výpočet skutečné komponenty, která je výsledkem násobení, vyhodnotí výraz 9e308 2,5 - 9e308 3,5. Každé přechodné násobení v tomto výrazu vrátí Double.PositiveInfinitya pokus o odečtení Double.PositiveInfinity od Double.PositiveInfinity návratů Double.NaN.
Formátování komplexního čísla
Ve výchozím nastavení má řetězcová reprezentace komplexního čísla tvar (skutečného, imagináře), kde reálné a imaginární jsou řetězcové reprezentace Double hodnot, které tvoří reálné a imaginární komponenty komplexního čísla. Některá přetížení ToString metody umožňují přizpůsobení řetězcových reprezentací těchto Double hodnot tak, aby odrážely konvence formátování konkrétní jazykové verze nebo se zobrazovaly v určitém formátu definovaném standardním nebo vlastním řetězcem číselného formátu. (Další informace najdete v tématu Standardní řetězce číselného formátu a vlastní řetězce číselného formátu.)
Jeden z nejběžnějších způsobů vyjádření řetězcového vyjádření komplexního čísla má tvar +BI, kde je reálná komponenta komplexního čísla a b je imaginární komponenta komplexního čísla. V elektrotechnikě se komplexní číslo nejčastěji vyjadřuje jako +bj. Řetězcové vyjádření komplexního čísla můžete vrátit v některé z těchto dvou forem. Chcete-li to provést, definujte vlastního zprostředkovatele formátu implementací ICustomFormatter a IFormatProvider rozhraní a pak zavolejte metodu String.Format(IFormatProvider, String, Object[]) .
Následující příklad definuje ComplexFormatter třídu, která představuje komplexní číslo jako řetězec ve formě buď + bi nebo + 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 pak použije tento vlastní formátovací modul k zobrazení řetězcové reprezentace komplexního čísla.
public class CustomFormatEx
{
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 Example2
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
Váš názor
Připravujeme: V průběhu roku 2024 budeme postupně vyřazovat problémy z GitHub coby mechanismus zpětné vazby pro obsah a nahrazovat ho novým systémem zpětné vazby. Další informace naleznete v tématu: https://aka.ms/ContentUserFeedback.
Odeslat a zobrazit názory pro