Complexes

Télécharger le projet
Commenter

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 :-)
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

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.

Du même auteur (cs_seboss)