Partage via

Complex.Addition Opérateur

  • Référence

Définition

Espace de noms:
System.Numerics
Assembly:
System.Runtime.Numerics.dll
Assembly:
System.Numerics.dll
Assembly:
netstandard.dll

Ajoute un nombre spécifié à un autre nombre spécifié, où au moins l’un d’eux est un nombre complexe, et l’autre peut être un nombre réel double précision.

Surcharges

Addition(Complex, Complex)

Ajoute deux nombres complexes.
Addition(Complex, Double)

Ajoute un nombre complexe à un nombre réel double précision.
Addition(Double, Complex)

Ajoute un nombre réel double précision à un nombre complexe.

Exemples

L’exemple suivant illustre l’ajout avec des nombres complexes :

using System;
using System.Numerics;

public class Example
{
   public static void Main()
   {
      Complex[] values= { new Complex(12.3, -1.4),
                          new Complex(-6.2, 3.1),
                          new Complex(8.9, 1.5) };
      foreach (var c1 in values)
         foreach (var c2 in values)
            Console.WriteLine("{0} + {1} = {2}", c1, c2, c1 + c2);
   }
}
// The example displays the following output:
//       (12.3, -1.4) + (12.3, -1.4) = (24.6, -2.8)
//       (12.3, -1.4) + (-6.2, 3.1) = (6.1, 1.7)
//       (12.3, -1.4) + (8.9, 1.5) = (21.2, 0.1)
//       (-6.2, 3.1) + (12.3, -1.4) = (6.1, 1.7)
//       (-6.2, 3.1) + (-6.2, 3.1) = (-12.4, 6.2)
//       (-6.2, 3.1) + (8.9, 1.5) = (2.7, 4.6)
//       (8.9, 1.5) + (12.3, -1.4) = (21.2, 0.1)
//       (8.9, 1.5) + (-6.2, 3.1) = (2.7, 4.6)
//       (8.9, 1.5) + (8.9, 1.5) = (17.8, 3)

open System.Numerics

let values = [ Complex(12.3, -1.4); Complex(-6.2, 3.1); Complex(8.9, 1.5) ]

for c1 in values do
    for c2 in values do
        printfn $"{c1} + {c2} = {c1 + c2}"
// The example displays the following output:
//       (12.3, -1.4) + (12.3, -1.4) = (24.6, -2.8)
//       (12.3, -1.4) + (-6.2, 3.1) = (6.1, 1.7)
//       (12.3, -1.4) + (8.9, 1.5) = (21.2, 0.1)
//       (-6.2, 3.1) + (12.3, -1.4) = (6.1, 1.7)
//       (-6.2, 3.1) + (-6.2, 3.1) = (-12.4, 6.2)
//       (-6.2, 3.1) + (8.9, 1.5) = (2.7, 4.6)
//       (8.9, 1.5) + (12.3, -1.4) = (21.2, 0.1)
//       (8.9, 1.5) + (-6.2, 3.1) = (2.7, 4.6)
//       (8.9, 1.5) + (8.9, 1.5) = (17.8, 3)

Imports System.Numerics

Module modMain
   Public Sub Main()
      Dim values() As Complex = { New Complex(12.3, -1.4), 
                                  New Complex(-6.2, 3.1), 
                                  New Complex(8.9, 1.5) }   
      For Each c1 In values
         For Each c2 In values
            Console.WriteLine("{0} + {1} = {2}", c1, c2, c1 + c2)
         Next
      Next      
   End Sub
End Module
' The example displays the following output:
'       (12.3, -1.4) + (12.3, -1.4) = (24.6, -2.8)
'       (12.3, -1.4) + (-6.2, 3.1) = (6.1, 1.7)
'       (12.3, -1.4) + (8.9, 1.5) = (21.2, 0.1)
'       (-6.2, 3.1) + (12.3, -1.4) = (6.1, 1.7)
'       (-6.2, 3.1) + (-6.2, 3.1) = (-12.4, 6.2)
'       (-6.2, 3.1) + (8.9, 1.5) = (2.7, 4.6)
'       (8.9, 1.5) + (12.3, -1.4) = (21.2, 0.1)
'       (8.9, 1.5) + (-6.2, 3.1) = (2.7, 4.6)
'       (8.9, 1.5) + (8.9, 1.5) = (17.8, 3)

Remarques

L’opérateur Addition permet d’effectuer des opérations d’ajout qui impliquent des nombres complexes. Il active le code comme suit :

Complex c1 = new Complex(1.2, 2.3);
Complex c2 = new Complex(2.1, 3.2);
Complex c3 = c1 + c2;

let c1 = Complex(1.2, 2.3)
let c2 = Complex(2.1, 3.2)
let c3 = c1 + c2

Dim c1 As New Complex(1.2, 2.3)
Dim c2 As New Complex(2.1, 3.2)
Dim c3 As Complex = c1 + c2

Si l’addition entraîne un dépassement de capacité dans le composant réel ou imaginaire, la valeur de ce composant est Double.PositiveInfinity ou Double.NegativeInfinity.

Les langages qui ne prennent pas en charge les opérateurs personnalisés peuvent appeler le Add groupe équivalent de méthodes à la place.

Les opérateurs Addition qui reçoivent un double sont plus efficaces que les opérateurs qui reçoivent deux nombres complexes.

Addition(Complex, Complex)

Source:
Complex.cs
Source:
Complex.cs
Source:
Complex.cs

Ajoute deux nombres complexes.

public:
 static System::Numerics::Complex operator +(System::Numerics::Complex left, System::Numerics::Complex right);
public:
 static System::Numerics::Complex operator +(System::Numerics::Complex left, System::Numerics::Complex right) = System::Numerics::IAdditionOperators<System::Numerics::Complex, System::Numerics::Complex, System::Numerics::Complex>::op_Addition;
public static System.Numerics.Complex operator + (System.Numerics.Complex left, System.Numerics.Complex right);
static member ( + ) : System.Numerics.Complex * System.Numerics.Complex -> System.Numerics.Complex
Public Shared Operator + (left As Complex, right As Complex) As Complex

Paramètres

left
Complex

Première valeur complexe à ajouter.

right
Complex

Deuxième valeur complexe à ajouter.

Retours

Complex

Somme de left et de right.

Implémente

Addition(TSelf, TOther)

Remarques

L’ajout d’un nombre complexe, a + biet un deuxième nombre complexe, c + di, prend la forme suivante :

$(a + c) + (b + d)i$

Les langages qui ne prennent pas en charge les opérateurs personnalisés peuvent appeler la Complex.Add(Complex, Double) méthode équivalente à la place.

Voir aussi

S’applique à

Addition(Complex, Double)

Source:
Complex.cs
Source:
Complex.cs
Source:
Complex.cs

Ajoute un nombre complexe à un nombre réel double précision.

public:
 static System::Numerics::Complex operator +(System::Numerics::Complex left, double right);
public static System.Numerics.Complex operator + (System.Numerics.Complex left, double right);
static member ( + ) : System.Numerics.Complex * double -> System.Numerics.Complex
Public Shared Operator + (left As Complex, right As Double) As Complex

Paramètres

left
Complex

Valeur complexe à ajouter.

right
Double

Valeur réelle double précision à ajouter.

Retours

Complex

Somme de left et de right en tant que nombre complexe.

Remarques

L’ajout d’un nombre complexe (a + bi) et d’un nombre réel (qui peut être considéré comme le nombre complexe c + 0i) prend la forme suivante :

$(a + c) + bi$

Les langages qui ne prennent pas en charge les opérateurs personnalisés peuvent appeler la Complex.Add(Double, Complex) méthode équivalente à la place.

Voir aussi

S’applique à

Addition(Double, Complex)

Source:
Complex.cs
Source:
Complex.cs
Source:
Complex.cs

Ajoute un nombre réel double précision à un nombre complexe.

public:
 static System::Numerics::Complex operator +(double left, System::Numerics::Complex right);
public static System.Numerics.Complex operator + (double left, System.Numerics.Complex right);
static member ( + ) : double * System.Numerics.Complex -> System.Numerics.Complex
Public Shared Operator + (left As Double, right As Complex) As Complex

Paramètres

left
Double

Valeur réelle double précision à ajouter.

right
Complex

Valeur complexe à ajouter.

Retours

Complex

Somme de left et de right en tant que nombre complexe.

Remarques

L’ajout d’un nombre réel (qui peut être considéré comme le nombre complexe a + 0i) et un nombre complexe (c + di) prend la forme suivante :

$(a + c) + di$

Les langages qui ne prennent pas en charge les opérateurs personnalisés peuvent appeler la Complex.Add(Double, Complex) méthode équivalente à la place.

Voir aussi

S’applique à