Calcul de nombres complexes, à l'aide d'une structure simple, surcharge des opérateurs courants et conversions implicites

Soyez le premier à donner votre avis sur cette source.

Snippet vu 20 034 fois - Téléchargée 20 fois

Contenu du snippet

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).

Source / Exemple :


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

Conclusion :


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!

A voir également

Ajouter un commentaire

Commentaires

Messages postés
144
Date d'inscription
lundi 13 octobre 2003
Statut
Membre
Dernière intervention
21 décembre 2014

De ce que j'ai compris, ils sont inutiles pour l'arithmétique parce qu'il n'existe pas d'interface Iarithmetic, (ou bien Iaddable + Isubstract + Imultipl + Idivise) et surtout on ne peut pas implémenter de tel interface car on ne peut pas ajouter les opérateurs dans les interfaces, aussi bien en VB que C#. Alors que apparement on peut le faire en C++, je devrais creuser la question mais je connais pas du tout C++.
Messages postés
1221
Date d'inscription
jeudi 23 août 2001
Statut
Membre
Dernière intervention
9 septembre 2018

Autant pour moi donc, mais je vais continuer à suivre l'affaire, car je suis déjà persuadé que les génériques ne sont pas aussi inutiles que ça (j'ai déjà utilisé un comparateur universel assez pratique pour trier facilement sur plusieurs clés n'importe quel tableau ou liste, ou bien pour sérialiser/désérialiser en une ligne de code n'importe quelle structure de données sérialisable), mais j'avoue que je n'ai pas bien saisi pourquoi certains pensent que les génériques sont inutiles pour l'arithmétique.
Messages postés
144
Date d'inscription
lundi 13 octobre 2003
Statut
Membre
Dernière intervention
21 décembre 2014

Après de longues recherches sur les génériques j'ai (enfin!) compris leur intérêt: exemple de déclaration:
Public Structure Complexe(of monType)
ensuite dans toute la classe je remplace Int32 par monType (!) ainsi je déclare les nombres complexes comme une partie réelel et une partie imaginaire en type générique (qui pourrait être Int32 comme ici, ou long ou double ou bien même une classe BigNum... de précision infinie... on peut rêver)
Sauf que, comme je viens de l'apprendre ici ( http://www.osnews.com/story.php/7930/The-Problem-with-.NET-Generics ) on ne peut pas implémenter d'interface iarithmetic en VB.NET (ni non plus C# apparement) ce qui nous interdit toute opération entre 2 variables déclarées as monType. on pourra au mieux utiliser une interface de comparaison (aucun intérêt pour les complexes). Et ça n'est d'aucune utilité par rapport à la surcharge des opérateurs entre un complexe et un numérique autre (int long double etc).
Messages postés
1221
Date d'inscription
jeudi 23 août 2001
Statut
Membre
Dernière intervention
9 septembre 2018

C'est indiqué ici :
http://fr.wikipedia.org/wiki/Nombre_complexe
Les nombres complexes ne peuvent pas avoir d'ordre.

Regarde d'abord à quoi servent les nombres complexes pour savoir ce qu'il est utile d'implémenter, à mon avis l'opérateur ^ ne sert pas à grand chose. Cependant, j'ai programmé les puissances 2, 3, 4 et 5 ici pour les images fractales :
http://patrice.dargenton.free.fr/fractal/FractalisSrc.html#228

Si tu utilises les génériques du DotNet2, normalement tu ne devrais pas avoir besoin de faire des surcharges pour chaque type (c'est justement l'intérêt de la chose).
Messages postés
144
Date d'inscription
lundi 13 octobre 2003
Statut
Membre
Dernière intervention
21 décembre 2014

MadMatt > en effet tu a raison sur ce point. (je laisserais quand meme à titre d'exemple de programmation les comparaisons mais j'ajouterais en commentaire que c'est pas valide mathématiquement)

Je viens juste de réaliser un truc: pour que mes opérateurs soient valables dans tous les cas, je dois encore plus les surcharger, genre A as Complexe + B as Long, A as Complexe + B as Double... et pour la commutativité ajouter aussi A as Long + B as Complexe ... etc si je veux prendre en compte tous les types et ceci pour toutes les opérations ça va nous faire un paquet de surcharges!!

Autre question: quelqu'un sait comment qu'on éleve un complexe à une puissance? pour implémenter l'opérateur ^ ! il y a forcément une méthode mais je ne sais plus laquelle...

Je ferais bientot une mise à jour avec une nouvelle classe pour les BigInt!
Afficher les 11 commentaires

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.