CALCUL DE NOMBRES COMPLEXES, À L'AIDE D'UNE STRUCTURE SIMPLE, SURCHARGE DES OPÉRATEURS COURANTS ET CONVERSIONS IMPLICITES

Public Class Complexe
    Implements IEquatable(Of Complexe), IFormattable, IComparable(Of Complexe)

    Private m_Reelle As Double      ' partie réelle
    Private m_Imaginaire As Double  ' partie imaginaire
    ' initialisation par défaut
    Public Shared ReadOnly Empty As Complexe = New Complexe(0, 0)
    Public Shared ReadOnly i As Complexe = New Complexe(0, 1)

    ''' <summary>
    ''' initialisation à partir d'une chaine de caractère de la forme a + ib => (a, b)
    ''' </summary>
    ''' <param name="cplx">complexe litéral de la forme a+ib</param>
    ''' <remarks></remarks>
    Public Sub New(ByVal cplx As String)
        Dim aNeg As Boolean
        Dim str_Reel As String = "0", str_Im As String = "0"

        cplx = cplx.Trim
        If cplx(0) = "-" Then aNeg = True
        If aNeg Or cplx(0) = "+" Then cplx = cplx.Remove(0, 1)

        If cplx.IndexOf("+") <> -1 Then ' a + ib
            str_Reel = cplx.Substring(0, cplx.IndexOf("+"))
            str_Im = cplx.Substring(cplx.IndexOf("+"))

        ElseIf cplx.IndexOf("-") <> -1 Then  ' a - ib
            str_Reel = cplx.Substring(1, cplx.IndexOf("-") - 1)
            str_Im = cplx.Substring(cplx.IndexOf("-"))

        ElseIf cplx.IndexOf("i") = -1 Then  'réel pur 

            str_Reel = cplx
        Else ' imaginaire pur
            str_Im = cplx
        End If

        m_Reelle = IIf(aNeg, -Val(str_Reel), Val(str_Reel))
        str_Im = str_Im.Replace("i", "").Replace("*", "")
        m_Imaginaire = Val(str_Im)

    End Sub

    ''' <summary>
    ''' initialisation usuelle (partie réelle, partie imaginaire)
    ''' </summary>
    ''' <param name="entierA">partie réelle</param>
    ''' <param name="imaginaireA">partie imaginaire</param>
    Public Sub New(ByVal entierA As Double, ByVal imaginaireA As Double)
        m_Reelle = entierA
        m_Imaginaire = imaginaireA
    End Sub

#Region "Propriétés (partie réelle imaginaire etc)"
    ''' <summary>
    ''' Partie réelle du nombre complexe
    ''' </summary>
    Public Property Reel() As Double
        Get
            Return m_Reelle
        End Get
        Set(ByVal value As Double)
            m_Reelle = value
        End Set
    End Property
    ''' <summary>
    ''' partie imaginaire du complexe
    ''' </summary>
    Public Property Imaginaire() As Double
        Get
            Return m_Imaginaire
        End Get
        Set(ByVal value As Double)
            m_Imaginaire = value
        End Set
    End Property

    ''' <summary>
    ''' Rotation avec un angle et un autre nombre complexe
    ''' </summary>
    ''' <param name="angle">angle de rotation en radians</param>
    ''' <param name="centre">centre de la rotation (complexe)</param>
    ''' <value></value>
    Public ReadOnly Property Rotation(ByVal angle As Double, ByVal centre As Complexe) As Complexe
        Get
            Return (((Me - centre) * (New Complexe(Math.Cos(angle), Math.Sin(angle)))) + centre)
        End Get
    End Property

    ''' <summary>
    ''' Conjugué du complexe (a-ib)
    ''' </summary>
    ''' <returns>a-ib</returns>
    Public ReadOnly Property Conjugue() As Complexe
        Get
            Return New Complexe(Me.m_Reelle, (-Me.m_Imaginaire))
        End Get
    End Property

    ''' <summary>
    ''' Module du complexe
    ''' </summary>
    ''' <value></value>
    ''' <returns>racine(a²+b²)</returns>
    Public ReadOnly Property [Module]() As Double
        Get
            Return Math.Sqrt(Me.m_Reelle ^ 2 + Me.m_Imaginaire ^ 2)
        End Get
    End Property

    ''' <summary>
    ''' Argument du complexe (arctan(imaginaire/reelle))
    ''' </summary>
    ''' <value></value>
    ''' <returns>arcTan(b/a)</returns>
    Public ReadOnly Property Argument() As Double
        Get
            Return Math.Atan(Me.m_Imaginaire / Me.m_Reelle)
        End Get
    End Property

    ''' <summary>
    ''' Carré du complexe ( Reel² - Img² ) / ( 2 Reel Img )
    ''' </summary>
    ''' <value></value>
    ''' <returns>(a²-b²)/(2ab)</returns>
    ''' <remarks></remarks>
    Public ReadOnly Property Carre() As Complexe
        Get
            Return New Complexe((Me.m_Reelle ^ 2 - Me.m_Imaginaire ^ 2), (2 * Me.m_Reelle * Me.m_Imaginaire))
        End Get
    End Property

#End Region

#Region "surcharge des opérateurs"
    Public Shared Operator +(ByVal c1 As Complexe, ByVal c2 As Complexe) As Complexe
        Return New Complexe(c1.Reel + c2.Reel, c1.Imaginaire + c2.Imaginaire)
    End Operator
    Public Shared Operator -(ByVal c1 As Complexe, ByVal c2 As Complexe) As Complexe
        Return New Complexe(c1.Reel - c2.Reel, c1.Imaginaire - c2.Imaginaire)
    End Operator
    Public Shared Operator *(ByVal c1 As Complexe, ByVal c2 As Complexe) As Complexe
        Return (New Complexe(((c1.Reel * c2.Reel) - (c1.Imaginaire * c2.Imaginaire)), ((c1.Reel * c2.Imaginaire) + (c2.Reel * c1.Imaginaire))))
    End Operator
    Public Shared Operator /(ByVal c1 As Complexe, ByVal c2 As Complexe) As Complexe
        Dim bgModule As BigInt = c2.Reel ^ 2 + c2.Imaginaire ^ 2
        Return New Complexe( _
            (c1.Reel * c2.Reel - c1.Imaginaire * c2.Imaginaire) / bgModule, _
            (c1.Reel * -c2.Imaginaire + c2.Reel * c1.Imaginaire) / bgModule)
    End Operator
    Public Shared Operator -(ByVal c1 As Complexe) As Complexe ' opérateur unitaire! 
        Return New Complexe(-c1.Reel, -c1.Imaginaire)
    End Operator

    ''' <summary>
    ''' opérateur d'égalité complexe: C1(a1, b1)=C2(a2, b2) vrai si a1=a2 et b1=b2
    ''' </summary>
    ''' <param name="a"></param>
    ''' <param name="b"></param>
    ''' <returns>boolean</returns>
    ''' <remarks>l'opérateur = implique l'opérateur <></remarks>
    Public Shared Operator =(ByVal a As Complexe, ByVal b As Complexe) As Boolean
        If (a.Reel = b.Reel AndAlso a.Imaginaire = b.Imaginaire) Then Return True
        Return False
    End Operator
    Public Shared Operator <>(ByVal a As Complexe, ByVal b As Complexe) As Boolean
        Return Not a = b
    End Operator

    ''' <summary>
    ''' Opérateurs simulant la comparaison de 2 complexes
    ''' </summary>
    ''' <param name="a"></param>
    ''' <param name="b"></param>
    ''' <returns></returns>
    ''' <remarks>AVERTISSEMENT /!\  les opérateurs de comparaison ci-dessous sont indiqué à titre d'exemple de programmation. Leur validité mathématique est NULLE, on ne peut PAS comparer 2 nombres complexes.</remarks>
    Public Shared Operator >(ByVal a As Complexe, ByVal b As Complexe) As Boolean
        If (a.Reel > b.Reel AndAlso a.Imaginaire >= b.Imaginaire) Then Return True
        Return False
    End Operator
    ' les autres comparaisons 'pourraient' être déduites de la précédente selon la logique des nombres réels
    ' il suffit de faire attention à ne pas induire de récursivité.
    Public Shared Operator <(ByVal a As Complexe, ByVal b As Complexe) As Boolean
        Return Not (a > b OrElse a = b)
    End Operator
    Public Shared Operator >=(ByVal a As Complexe, ByVal b As Complexe) As Boolean
        Return a > b OrElse a = b
    End Operator
    Public Shared Operator <=(ByVal a As Complexe, ByVal b As Complexe) As Boolean
        Return Not a > b
    End Operator

#End Region

#Region "Conversions explicites et implicites"

    ''' <summary>
    ''' conversion implicite, double => complexe, automatique et sans perte de données
    ''' </summary>
    ''' <param name="a"></param>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public Shared Widening Operator CType(ByVal a As Long) As Complexe
        Return New Complexe(a, 0)
    End Operator
    ''' <summary>
    ''' conversion implicite, Long => complexe, automatique et sans perte de données
    ''' </summary>
    ''' <param name="a"></param>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public Shared Widening Operator CType(ByVal a As Double) As Complexe
        Return New Complexe(a, 0)
    End Operator
    ''' <summary>
    ''' conversion implicite String => complexe !
    ''' </summary>
    ''' <param name="a"></param>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public Shared Widening Operator CType(ByVal a As String) As Complexe
        Return New Complexe(a)
    End Operator

    ''' <summary>
    ''' conversion explicite Complexe => BigInt (avertissement éventuel)
    ''' </summary>
    ''' <param name="c"></param>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public Shared Narrowing Operator CType(ByVal c As Complexe) As Double
        If c.Imaginaire <> 0 Then Throw New ArgumentException("Conversion impossible")
        Return c.Reel
    End Operator
    ''' <summary>
    ''' conversion explicite Complexe => String
    ''' </summary>
    ''' <param name="c"></param>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public Shared Widening Operator CType(ByVal c As Complexe) As String
        Return c.Reel & IIf(Math.Sign(c.Imaginaire) <> 0, IIf(Math.Sign(c.Imaginaire) > 0, "+", "-") & _
            "i" & IIf(Math.Sign(c.Imaginaire) <> 1, Math.Abs(c.Imaginaire), ""), "")
    End Operator

    ''' <summary>
    ''' conversion en string
    ''' </summary>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Overloads Function ToString() As String
        Dim strResult As String = ""
        If Me.m_Reelle <> 0 Then strResult = Convert.ToString(Me.m_Reelle)
        If Me.m_Imaginaire = 1 Then
            Return strResult & "+i"
        ElseIf Me.m_Imaginaire = -1 Then
            Return strResult & "-i"
        ElseIf Me.m_Imaginaire > 0 Then
            Return strResult & "+i*" & Math.Abs(Me.m_Imaginaire)
        ElseIf Me.m_Imaginaire < 0 Then
            Return strResult & "-i*" & Math.Abs(Me.m_Imaginaire)
        ElseIf Me.m_Reelle <> 0 Then
            Return strResult
        Else
            Return "0"
        End If
    End Function

    ''' <summary>
    ''' interface de comparaison implémtenté bien que les complexes ne peuvent pas être comparés /!\ (à titre d'exemple donc)
    ''' </summary>
    ''' <param name="c"></param>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public Overloads Function CompareTo(ByVal c As Complexe) As Integer Implements IComparable(Of Complexe).CompareTo
        If c > Me Then Return 1 Else If c = Me Then Return 0 Else Return -1
    End Function

    Public Overloads Function Equals(ByVal c As Complexe) As Boolean Implements IEquatable(Of Complexe).Equals
        Return Me = c
    End Function

    Public Overloads Function ToString(ByVal format As String, ByVal iformat As IFormatProvider) As String Implements IFormattable.ToString
        Return ""
    End Function

#End Region

End Class

02 mai 2007 11:15:53 :

Ajout des interfaces IEquatable(Of Complexe), IFormattable, IComparable(Of Complexe) (cette dernière étant mathématiquement invalide, mais juste pour l'exemple) ainsi que les conversions implicites (Public Shared Widening Operator CType(ByVal a As Long) As Complexe ...) Ceci nous permet de faire des opérations sur 2 types différents (Long + Complexe, Double + Complexe) le tout est automatiquement et implicitement converti en complexe.