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

---

Commentaire sur cette source (11)
Ajouter un commentaire et/ou une note

Voici transposé en VB ce qui je suppose existe depuis longtemps dans d'autres langages objets... la création d'un type de donnée complexe, qui permet les opérations (+ - / *) comparaison (= <> > <) et conversions de base (string, entier si possible)  implicites. l'utilisation évidente:

Dim X as new complexe(1, 2), Y as new complexe(3, 4)
Dim C as complexe = X + Y ' opération de 2 complexes
msgbox C ' conversion implicite vers String de la forme a+i*b

en prime quelques propriétés simples (partie réelle, imaginaire, module, argument, etc).

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

C'est typiquement un exercice pour créer une nouvelle structure de données (j'espère que les formules mathématiques sont quand même correctes car mes années d'étude sont déjà loin, n'hésitez pas à me reprendre à ce sujet!)

La conversion String => complexe est un peu à l'arrache, il faut impérativement une chaine "a+i*b" ou "a+ib" ... par exemple "i+1" ou "4-3*i+1" ça passera pas, j'ai pas fais un algo de calcul formel non plus...

Pour continuer sur l'étude des structures je voudrais implémenter les interfaces! Si vous avez de l'aide à ce sujet (msdn ne m'a pas aidé). C'est le commentaire en 1ere ligne:
    'Implements IComparable, IConvertible, IEquatable(Of Complexe), IFormattable, IComparable(Of Long)

Quand j'en aurais terminé avec les complexes je ferais la même choses avec les BigNum les nombres 'infini' pour dépasser les limitations des long et double. Toute suggestion bienvenue, merci!

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.

• FONCTION ENVOI DE MAIL PAR VBA SANS CLIENT LOCAL, PAR SERVEUR SMTP
• FONCTIONS INSERT UPDATE POUR ACCESS PROJET ADP
• STRUCTURE MATRICE : SURCHARGE DES OPÉRATEURS POUR LE CALCUL MATRICIEL, INVERSION TRACE DÉTERMINANT ET AUTRES OPÉRATIONS
• BIGINT! UNE STRUCTURE POUR SURCHARGER LES ENTIERS (LONG) SANS LIMITE DE TAILLE. SURCHARGE DES OPÉRATIONS ET COMPARAISONS DE BASE
• [ACCESS] ATTACHER / DÉTACHER DES TABLES LIÉES

• EQUATION DU SECOND DEGRÉ RÉSOLUE AVEC DEUX METHODES
• PROJECTION SOLEIL
• INTERRUPTEUR ALÉATOIRE
• PROBABILITES
• PIVOT DE GAUSS

• STRUCTURE MATRICE : SURCHARGE DES OPÉRATEURS POUR LE CALCUL MATRICIEL, INVERSION TRACE DÉTERMINANT ET AUTRES OPÉRATIONS
• BIGINT! UNE STRUCTURE POUR SURCHARGER LES ENTIERS (LONG) SANS LIMITE DE TAILLE. SURCHARGE DES OPÉRATIONS ET COMPARAISONS DE BASE
• SURCHARGE D'OPERATEUR VB5/6
• CHIFFRE EN LETTRE FONCTION
• LES NOMBRES COMPLEXES