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