Complexes

Soyez le premier à donner votre avis sur cette source.

Vue 16 399 fois - Téléchargée 501 fois

Description

C'est une structure pouvant manipuler les bases des complexes (operations de base, module, argument, etc..) pour pouvoir jouer avec les complexes dans n'importe quelle application !

La structure que j'ai ecrite nommé Complexe comporte :
  • 1 constructeur pour créer de nouveau complexe :


// Création du complexe 3-i5
Complexe monComplexe = new Complexe(3,-5);
  • 2 accesseurs en get/set pour pouvoir recuperer ou modifier les parties Reelles et Imaginaires du complexe


// Recuperation de la partie Reele dans a :
double a = monComplexe.Reel;
// Modification de la partie Imaginaire à -8 :
monComplexe.Imaginaire = -8;
  • 4 accesseurs en lecture seule (get seulement) pour récupérer le Conjugué, le module, l'argument et le carré d'un complexe :


// Conjugué (retourne un nouveau Complexe) :
Complexe le_conjugue = monComplexe.Conjugue;
// Module (retourne un double) :
double module = monComplexe.Module;
// Argument (retourne un double) :
double argument = monComplexe.Argument;
// Carré du complexe (retourne un nouveau Complexe) :
Complexe au_carre = monComplexe.Carre;
  • 1 méthode : Rotation qui retourne un nouveau complexe de la rotation du complexe par un angle (en double) et d'un centre (Complexe)


// Rotation de monComplexe d'angle 3.0 par le centre 2+i4
Complexe nouveau_point = monComplexe.Rotation(3.0,new Complexe(2,4));
  • 4 surcharges d'operateurs pour les operations +, -, *, / respectivement addition, soustration, multiplication, division :


Complexe cmp1, cmp2, resultat;
cmp1 = new Complexe(3,-6);
cmp2 = new Complexe(6,7);
// Addition de cmp1 par cmp2
resultat = cmp1 + cmp2;
// Soustraction de cmp1 par cmp2
resultat = cmp1 - cmp2;
// Multiplication de cmp1 par cmp2
resultat = cmp1 * cmp2;
// Division de cmp1 pr cmp2
resultat = cmp1 + cmp2;
  • Et pour finir 1 surcharge de la methode ToString() afin de pouvoir recuperer le complexe en string sous la forme a+ib :


Complexe monComplexe = new Complexe(4,-5);
Console.WriteLine(monComplexe); // Affiche a l'ecran : 4-5i

Source / Exemple :


/*

	Structure COMPLEXE
	Gestion des nombres Complexes
	Version 1.0 - Last Modif : 21/04/2006 15:52
	Développé par SeBeuh < sebeuh [arobase] ajsinfo [point].net >
	(c) 2006 - http://sebeuh.ajsinfo.net

  • /
using System; using System.Collections.Generic; using System.Text; namespace Complexes { // Structure : Complexe public struct Complexe { // Champs private double _reel; private double _imaginaire; // Constructeur public Complexe(double reel, double imaginaire) { this._reel = reel; this._imaginaire = imaginaire; } // Surcharge de la methode ToString() // renvoi du complexe sous la forme a+ib public override string ToString() { string re = "", img = ""; if(this._reel != 0) re = ((float)this._reel).ToString(); if (this._imaginaire > 0 && this._imaginaire != 1) img = "+" + ((float)this._imaginaire).ToString() + "i"; else if (this._imaginaire == 1) img = "+i"; else if (this._imaginaire < 0 && this._imaginaire != -1) img = ((float)this._imaginaire).ToString() + "i"; else if (this._imaginaire == -1) img = "-i"; return (re + img); } // Surcharge des operateurs // Addition public static Complexe operator +(Complexe c1, Complexe c2) { return (new Complexe((c1.Reel + c2.Reel), (c1.Imaginaire + c2.Imaginaire))); } // Soustraction public static Complexe operator -(Complexe c1, Complexe c2) { return (new Complexe((c1.Reel - c2.Reel), (c1.Imaginaire - c2.Imaginaire))); } // Multiplication public static Complexe operator *(Complexe c1, Complexe c2) { return (new Complexe(((c1.Reel * c2.Reel) - (c1.Imaginaire * c2.Imaginaire)), ((c1.Reel * c2.Imaginaire) + (c2.Reel * c1.Imaginaire)))); } // Division public static Complexe operator /(Complexe c1, Complexe c2) { return (new Complexe(((c1._reel * c2._reel - c1._imaginaire * (-c2._imaginaire)) / (Math.Pow(c2._reel, 2) + Math.Pow(c2._imaginaire, 2))), ( ((c1._reel * (-c2._imaginaire) + c2._reel * c1._imaginaire) / (Math.Pow(c2._reel, 2) + Math.Pow(c2._imaginaire, 2)))))); } // Methodes // Rotation public Complexe Rotation(double angle, Complexe centre) { return (((this - centre) * (new Complexe(Math.Cos(angle), Math.Sin(angle)))) + centre); } // Accesseurs en Get (read only) // Conjugué du complexe public Complexe Conjugue { get { return new Complexe(this._reel, (0 - this._imaginaire)); } } // Module du complexe public double Module { get { return Math.Sqrt((Math.Pow(this._reel, 2) + Math.Pow(this._imaginaire, 2))); } } // Argument du complexe public double Argument { get { return (Math.Atan((this._imaginaire / this._reel))); } } // Carré du complexe public Complexe Carre { get { return new Complexe((Math.Pow(this._reel,2)-Math.Pow(this._imaginaire,2)),(2*this._reel*this._imaginaire)); } } // Accesseurs en Get&Set // Partie Reel public double Reel { get { return this._reel; } set { this._reel = value; } } // Partie Imaginaire public double Imaginaire { get { return this._imaginaire; } set { this._imaginaire = value; } } } }

Conclusion :


Bref il y a toutes les fonctions de bases sur les complexes pour pouvoir les utiliser très facilement dans vos développements :-)

Codes Sources

A voir également

Ajouter un commentaire Commentaires
Messages postés
1
Date d'inscription
mardi 2 juin 2009
Statut
Membre
Dernière intervention
19 février 2010

Il y a un problème avec l'argument : la fonction Atan donne un angle compris entre -pi/2 et pi/2 et donc l'argument proposé est faux pour les complexes dont la partie réelle est négative. La fonction Atan2 tient compte du signe de ses 2 arguments et permet donc de couvrir tous les cas.

À propos de la surcharge des opérateurs : C# ne permet pas de surcharger les opérateurs d'affectation (+= -= *= /=), ils sont automatiquement surchargés quand l'opérateur arithmétique correspondant l'est. En revanche, les opérateurs == et != seraient bien utiles, n'étant pas utilisables par défaut sur les struct.

Par ailleurs, j'ajouterais une conversion implicite de double vers Complexe pour pouvoir mélanger réels et complexes dans les expressions.
Messages postés
514
Date d'inscription
mercredi 19 mars 2003
Statut
Membre
Dernière intervention
1 mars 2009

Autre suggestion : gère les exceptions (en fait, là, comme ça, j'en voie qu'une : la division par un complexe nul)
++ !
Messages postés
1024
Date d'inscription
mardi 4 février 2003
Statut
Membre
Dernière intervention
7 juin 2010
64
Classique, mais bien réalisé.

Suggestion : surcharger les opérateurs +=, -+, *=, /=, == et !=.
Messages postés
26
Date d'inscription
samedi 15 octobre 2005
Statut
Membre
Dernière intervention
27 juillet 2006

Trés bon code, c'est trés utile pour les applications math..le code est lisible, court et parfait..
Messages postés
4030
Date d'inscription
mardi 13 mai 2003
Statut
Modérateur
Dernière intervention
23 décembre 2008
22
Les complexes sont un sujet inépuisable d'utilisation et de familiarisation avec la programmation objet. C'est proprement codé. Bien joué.

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.