Accueil > > > ENSEMBLE COMPLEXE
ENSEMBLE COMPLEXE
Information sur la source
Description
Il existe différents types en java, caractère, boolean, entier, réel... Mais il n'existe pas de type complexe pour réaliser des opérations dans C, alors j'ai créé moi même une petite classe complexe qui permet de faire addition, soustraction, conjugaison, multiplication, division, inversion, racine nième et puissance nième.
Source
- public class Complexe {
-
- private double im;
- private double re;
- private double arg;
- private double mod;
-
- //##############################################
- //constructeurs (a+ib)
- //pour entrer a et b séparément
- public Complexe(double reel, double imag) {
- im = imag;
- re = reel;
- this.modArg();
- }
- //pour entrer le nombre sous la forme "a+ib"
- public Complexe(String aib) {
- this.decompose(aib);
- this.modArg();
- }
-
- //##############################################
- //méthodes annexes pour les constructeurs
- //permet de décomposer une string "a+ib" en 2 nombres, a et b
- private void decompose(String aib) {
- String a;
- String b;
- if(aib.indexOf("i") == 0 && aib.length() == 1){
- a = "0";
- b = "1";
- } else if(aib.indexOf("-") == 0 && aib.indexOf("i") == 1 && aib.length() == 2) {
- a = "0";
- b = "-1";
- } else if(aib.indexOf("+") != -1) {
- a = aib.substring(0,aib.indexOf("+"));
- b = aib.substring((aib.indexOf("+")+1), aib.indexOf("i"));
- if(b.length() == 0) {
- b = aib.substring((aib.indexOf("i")+1),aib.length());
- }
- } else if(aib.indexOf("-") != -1) {
- if(aib.indexOf("-") == 0) {
- a = "0";
- b = aib.substring((aib.indexOf("-")), aib.indexOf("i"));
- } else {
- a = aib.substring(0,aib.indexOf("-"));
- b = aib.substring((aib.indexOf("-")), aib.indexOf("i"));
- }
- if(b.length() == 1) {
- b = "-" + aib.substring((aib.indexOf("i")+1),aib.length());
- }
- } else if(aib.indexOf("i") != -1) {
- a = "0";
- b = aib.substring(0, aib.indexOf("i"));
- if(b.length() == 0) {
- b = aib.substring((aib.indexOf("i")+1),aib.length());
- }
- } else {
- a = aib;
- b = "0";
- }
- try {
- re = Integer.parseInt(a);
- im = Integer.parseInt(b);
- } catch(NumberFormatException e) {
- System.out.println("Erreur, Mauvais format de nombre");
- re = 0;
- im = 0;
- }
- }
- //méthode pour récupérer le module |z| et l'argument Arg(z) à partir des nombres a et b
- private void modArg() {
- mod = Math.sqrt((re*re + im*im));
- if(re != 0 && im != 0) {
- arg = Math.atan((im/re));
- } else if (re != 0 && im == 0) {
- if(im >= 0) {
- arg = 0;
- } else if(im < 0) {
- arg = Math.PI;
- }
- } else if(re == 0 && im != 0){
- if(im >= 0) {
- arg = Math.PI/2;
- } else {
- arg = -Math.PI/2;
- }
- }
- }
-
-
- //##############################################
- //Opérations sur les complexes
-
-
- //conjugué a+ib -> a-ib
- public Complexe conj() {
- Complexe conj = new Complexe(re, -im);
- return conj;
- }
-
- //addition (a+ib)+(c+id)
- public Complexe add(Complexe comp) {
- double imag = im + comp.getIm();
- double reel = re + comp.getRe();
- Complexe add = new Complexe(reel, imag);
- return add;
- }
-
- //soustraction (a+ib)-(c+id)
- public Complexe minus(Complexe comp) {
- double imag = im - comp.getIm();
- double reel = re - comp.getRe();
- Complexe minus = new Complexe(reel, imag);
- return minus;
- }
-
- // multiplication (a+ib)*(c+id)
- public Complexe time(Complexe comp) {
- double imag = im*comp.getRe() + re*comp.getIm();
- double reel = re*comp.getRe() - im*comp.getIm();
- Complexe time = new Complexe(reel, imag);
- return time;
- }
-
- //inversion 1/(a+ib)
- public Complexe inverse() {
- double imag = (-im)/(mod*mod);
- double reel = re/(mod*mod);
- Complexe inverse = new Complexe(reel, imag);
- return inverse;
- }
-
- //division (a+ib)/(c+id)
- public Complexe divide(Complexe comp) {
- return time(comp.inverse());
- }
-
- //puissance (a+ib)^x
- //pour les puissances 0 < x < 1, utiliser la racine (.root(int))
- //pour les puissances x < 0, meixu vaut faire la puissance |x| puis une inversion
- public Complexe pow(double x) {
- double argu = arg*x;
- double modu = Math.pow(mod, x);
- double imag = reduce(modu*Math.sin(argu));
- double reel = reduce(modu*Math.cos(argu));
- Complexe pow = new Complexe(reel, imag);
- return pow;
- }
-
- //racine xroot(a+ib) !!!ATTENTION: x != 0
- //racines entières seulement (sinon il y en a une infitinité)
- //Si x appartient à N, il y a x racines, raison pour laquelle cette méthode retourne un tableau
- //pour les racines 0 < x < 1, utiliser la puissance (.pow(int))
- //pour les racines x < 0, meixu vaut faire la racine |x| puis une inversion
- public Complexe[] root(int x) {
- Complexe[] root = new Complexe[x];
- double modu;
- double reel;
- double imag;
- double argu;
- if(x != 0 ) {
- modu = Math.pow(mod, (1/x));
- } else {
- modu = 0;
- }
- for(int i = 0; i < x; i++) {
- argu = (arg+2*i*Math.PI)/x;
- imag = reduce(modu*Math.sin(argu));
- reel = reduce(modu*Math.cos(argu));
- root[i]= new Complexe(reel, imag);
- }
- return root;
- }
-
-
- //################################################
- //Getters
- public double getIm() {
- return im;
- }
-
- public double getRe() {
- return re;
- }
-
- //#################################################
- //autres méthodes utiles
- //permet de réduire un nombre à 2 décimale seulement.
- //pour changer la réduction, il suffit de changer 1000
- //méthode utilisée dans les méthodes racines et puissance, peut être retirée facilement
- private double reduce(double nombre) {
- double n = nombre * 1000;
- n = (int)n;
- n = n / 1000;
- return n;
- }
-
- //redéfinition de la méthode toString(), pour qu'elle affiche le nombre sous la forme a+ib
- public String toString() {
- String out = "";
- if(re == 0) {
- if(im == 0) {
- out += "0";
- } else if(im == 1) {
- out += "i";
- } else if(im == -1) {
- out += "-i";
- } else {
- out += im + "i";
- }
- } else {
- out += re;
- if(im == 0) {
- out += "";
- } else if(im == 1) {
- out += "+i";
- } else if(im == -1) {
- out += "-i";
- } else if(im > 0){
- out += "+" + im + "i";
- } else {
- out += im + "i";
- }
- }
- return out;
- }
-
- //redéfinition de la méthode equals(), pour comparer si deux nombres complexes sont identiques
- //on ne peut pas évaluer si un nombre complexe est supérieur ou inférieur à un autre
- //on ne peut que savoir s'ils sont égaux (même partie réelle et même même partie imaginaire)
- public boolean equals(Object o) {
- if(o != null && o.getClass() == this.getClass()){
- Complexe comp = (Complexe) o;
- return (this.re == comp.getRe() && this.im == comp.getIm());
- } else {
- return false;
- }
- }
- }
public class Complexe {
private double im;
private double re;
private double arg;
private double mod;
//##############################################
//constructeurs (a+ib)
//pour entrer a et b séparément
public Complexe(double reel, double imag) {
im = imag;
re = reel;
this.modArg();
}
//pour entrer le nombre sous la forme "a+ib"
public Complexe(String aib) {
this.decompose(aib);
this.modArg();
}
//##############################################
//méthodes annexes pour les constructeurs
//permet de décomposer une string "a+ib" en 2 nombres, a et b
private void decompose(String aib) {
String a;
String b;
if(aib.indexOf("i") == 0 && aib.length() == 1){
a = "0";
b = "1";
} else if(aib.indexOf("-") == 0 && aib.indexOf("i") == 1 && aib.length() == 2) {
a = "0";
b = "-1";
} else if(aib.indexOf("+") != -1) {
a = aib.substring(0,aib.indexOf("+"));
b = aib.substring((aib.indexOf("+")+1), aib.indexOf("i"));
if(b.length() == 0) {
b = aib.substring((aib.indexOf("i")+1),aib.length());
}
} else if(aib.indexOf("-") != -1) {
if(aib.indexOf("-") == 0) {
a = "0";
b = aib.substring((aib.indexOf("-")), aib.indexOf("i"));
} else {
a = aib.substring(0,aib.indexOf("-"));
b = aib.substring((aib.indexOf("-")), aib.indexOf("i"));
}
if(b.length() == 1) {
b = "-" + aib.substring((aib.indexOf("i")+1),aib.length());
}
} else if(aib.indexOf("i") != -1) {
a = "0";
b = aib.substring(0, aib.indexOf("i"));
if(b.length() == 0) {
b = aib.substring((aib.indexOf("i")+1),aib.length());
}
} else {
a = aib;
b = "0";
}
try {
re = Integer.parseInt(a);
im = Integer.parseInt(b);
} catch(NumberFormatException e) {
System.out.println("Erreur, Mauvais format de nombre");
re = 0;
im = 0;
}
}
//méthode pour récupérer le module |z| et l'argument Arg(z) à partir des nombres a et b
private void modArg() {
mod = Math.sqrt((re*re + im*im));
if(re != 0 && im != 0) {
arg = Math.atan((im/re));
} else if (re != 0 && im == 0) {
if(im >= 0) {
arg = 0;
} else if(im < 0) {
arg = Math.PI;
}
} else if(re == 0 && im != 0){
if(im >= 0) {
arg = Math.PI/2;
} else {
arg = -Math.PI/2;
}
}
}
//##############################################
//Opérations sur les complexes
//conjugué a+ib -> a-ib
public Complexe conj() {
Complexe conj = new Complexe(re, -im);
return conj;
}
//addition (a+ib)+(c+id)
public Complexe add(Complexe comp) {
double imag = im + comp.getIm();
double reel = re + comp.getRe();
Complexe add = new Complexe(reel, imag);
return add;
}
//soustraction (a+ib)-(c+id)
public Complexe minus(Complexe comp) {
double imag = im - comp.getIm();
double reel = re - comp.getRe();
Complexe minus = new Complexe(reel, imag);
return minus;
}
// multiplication (a+ib)*(c+id)
public Complexe time(Complexe comp) {
double imag = im*comp.getRe() + re*comp.getIm();
double reel = re*comp.getRe() - im*comp.getIm();
Complexe time = new Complexe(reel, imag);
return time;
}
//inversion 1/(a+ib)
public Complexe inverse() {
double imag = (-im)/(mod*mod);
double reel = re/(mod*mod);
Complexe inverse = new Complexe(reel, imag);
return inverse;
}
//division (a+ib)/(c+id)
public Complexe divide(Complexe comp) {
return time(comp.inverse());
}
//puissance (a+ib)^x
//pour les puissances 0 < x < 1, utiliser la racine (.root(int))
//pour les puissances x < 0, meixu vaut faire la puissance |x| puis une inversion
public Complexe pow(double x) {
double argu = arg*x;
double modu = Math.pow(mod, x);
double imag = reduce(modu*Math.sin(argu));
double reel = reduce(modu*Math.cos(argu));
Complexe pow = new Complexe(reel, imag);
return pow;
}
//racine xroot(a+ib) !!!ATTENTION: x != 0
//racines entières seulement (sinon il y en a une infitinité)
//Si x appartient à N, il y a x racines, raison pour laquelle cette méthode retourne un tableau
//pour les racines 0 < x < 1, utiliser la puissance (.pow(int))
//pour les racines x < 0, meixu vaut faire la racine |x| puis une inversion
public Complexe[] root(int x) {
Complexe[] root = new Complexe[x];
double modu;
double reel;
double imag;
double argu;
if(x != 0 ) {
modu = Math.pow(mod, (1/x));
} else {
modu = 0;
}
for(int i = 0; i < x; i++) {
argu = (arg+2*i*Math.PI)/x;
imag = reduce(modu*Math.sin(argu));
reel = reduce(modu*Math.cos(argu));
root[i]= new Complexe(reel, imag);
}
return root;
}
//################################################
//Getters
public double getIm() {
return im;
}
public double getRe() {
return re;
}
//#################################################
//autres méthodes utiles
//permet de réduire un nombre à 2 décimale seulement.
//pour changer la réduction, il suffit de changer 1000
//méthode utilisée dans les méthodes racines et puissance, peut être retirée facilement
private double reduce(double nombre) {
double n = nombre * 1000;
n = (int)n;
n = n / 1000;
return n;
}
//redéfinition de la méthode toString(), pour qu'elle affiche le nombre sous la forme a+ib
public String toString() {
String out = "";
if(re == 0) {
if(im == 0) {
out += "0";
} else if(im == 1) {
out += "i";
} else if(im == -1) {
out += "-i";
} else {
out += im + "i";
}
} else {
out += re;
if(im == 0) {
out += "";
} else if(im == 1) {
out += "+i";
} else if(im == -1) {
out += "-i";
} else if(im > 0){
out += "+" + im + "i";
} else {
out += im + "i";
}
}
return out;
}
//redéfinition de la méthode equals(), pour comparer si deux nombres complexes sont identiques
//on ne peut pas évaluer si un nombre complexe est supérieur ou inférieur à un autre
//on ne peut que savoir s'ils sont égaux (même partie réelle et même même partie imaginaire)
public boolean equals(Object o) {
if(o != null && o.getClass() == this.getClass()){
Complexe comp = (Complexe) o;
return (this.re == comp.getRe() && this.im == comp.getIm());
} else {
return false;
}
}
}
Conclusion
Si vous trouvez des erreurs, dites le moi. Si vous ne comprenez pas certains points du code, dites moi, je commenterai plus spécifiquement.
Historique
- 01 décembre 2008 18:33:33 :
- Ajout d'une méthode equals(Complexe) pour savoir si deux nombres sont identiques.
- 01 décembre 2008 19:41:40 :
- Modification de la méthode decompose(String) afin qu'elle gère les nombres négatifs et "i" et "-i"
- 02 décembre 2008 20:22:36 :
- Quelques modifications dans la méthode decompose(String) et dans la méthode equals(Complexe)
- 04 décembre 2008 19:56:49 :
- Modification de la méthode .equals(Complexe) pour qu'elle reconnaisse si un objet est null
- 05 décembre 2008 11:21:52 :
- Modification de la méthode .equals(Object) pour qu'elle puisse comparer un complexe avec n'importe quel auter objet
Sources de la même categorie
Commentaires et avis
Discussions en rapport avec ce code source dans le forum
{Graphics2D] Arc de Cercle [ par deejimy ]
Je récupère à partir d'un fichier txt, les coordonnées du centre de l'arc(x,y), le rayon r , l'angle de début d et l'angle de fin f. Je n'arrive pas à
[Math]Manipuler les exposant avec un float [ par djodjoo ]
Salut tous,Voilà mon problème, j'aimerais pouvoir manipuler les nombre tel qque 2.12E-4 par exemple.Ce que j'aimerais pouvoir faire : &
Math.pow(10, 10) me renvoit 2147483647 [ par alonsyl ]
bonjour,Math.pow(10, 10) me renvoit 2147483647 ! moi j'aimerais qu'il me renvoit 10^10 = 10000000000.que se passe t'il ? comment resoudre ce pbl ?merc
midlet j2me ou est passé java.lang.Math.log [ par misterzinzin ]
bonjour, je vien de commencer la programmation de midlet (java pour mobile) et je ne trouva pas la fonction permettant de calculer des logarithme dans
Calcul de mémoire ... [ par threadom ]
Bon d'abord j'explique ...En gros L_oStream.getFrameLength() me retourne un long qui m'indique combien de byte vont mettre retourné, et je veux stocke
Arrondi à n chiffres significatifs [ par juancho2786 ]
Bonsoir , je fais une méthode qui permet d'arrondir à n chiffres significatis seulement j'ai un problème. Par exemple lorsque le nombre à arrondir est
double != Double [ par lafolle24320 ]
Bonjour à tous, est ce que quelqu'un pourrait m'expliquer clairement la différence entre un double et un Double. En fait j'ai un calcul : avec beam en
Sortir un zéro avec un Math.random()*10+1 [ par daviddubois ]
Bonjour tout le monde,J'essaie d'avoir des chiffres de 0 à 10 avec un Math.random(), le problème est qu'il sort des chiffres entre 1 et 10.Il ne sort
la fonction Math.random() [ par dorine82 ]
bonjour,j'aimerais savoir comment utiliser deux threads chacun a son tour. si par exemple j' ai le thread A et le thread B , je dois avoir comme resul
tableau sans repitition [ par gigi00 ]
bonjourj ai besoin d' aide pour faire fonctioner se programmedans ce programme je veux réaliser un tableau de [9][9] et qui rempli aleatoirement les c
|
Derniers Blogs
PARUTION DE MON LIVRE SUR WPF 4PARUTION DE MON LIVRE SUR WPF 4 par odewit
La 2e édition de mon livre sur WPF sort aujourd'hui en version numérique et lundi en version papier :-)
L'ouvrage présente de façon approfondie les fonctionnalités de WPF 4 : graphisme 2D et 3D, animation, multimédia, interfaces utilisateur, databind...
Cliquez pour lire la suite de l'article par odewit EDM : COMMENT UTILISER L'HORIZONTAL ENTITY SPLITTINGEDM : COMMENT UTILISER L'HORIZONTAL ENTITY SPLITTING par Matthieu MEZIL
Une des raisons pour lesquelles j'adore l'Entity Framework est la puissance de son mapping. Beaucoup de développeurs pour ne pas dire la plus part n'en n'ont pas conscience. Pour rappel, j'ai réalisé des videos (en anglais) sur le mapping . Certains scena...
Cliquez pour lire la suite de l'article par Matthieu MEZIL [WP7DEV][REACTIVE] RENDRE LES REACTIVE EXTENSIONS PLUS STABLES[WP7DEV][REACTIVE] RENDRE LES REACTIVE EXTENSIONS PLUS STABLES par jay
Lorsque l'on développe des applications .NET, les exceptions non gérées dans des threads ont le désagréable effet de terminer le processus courant.
Dans l'exemple suivant.......(read more) ...
Cliquez pour lire la suite de l'article par jay WINDBG / SOS / PSSCOR2 : FAILED TO LOAD DATA ACCESS DLL (MSCORDACWKS)WINDBG / SOS / PSSCOR2 : FAILED TO LOAD DATA ACCESS DLL (MSCORDACWKS) par coq
Ceux d'entre nous qui analysent des dumps d'applications .NET (notamment ceux créés via WER après un crash) en dehors de l'environnement initial ont probablement tous été confrontés au moins une fois au message suivant, à la saisie d'une commande SOS ...
Cliquez pour lire la suite de l'article par coq
Logiciels
Microsoft Office (2010)MICROSOFT OFFICE (2010)Microsoft Office 2010 offre de nouveaux moyens flexibles et puissants pour optimiser votre travai... Cliquez pour télécharger Microsoft Office SeaMonkey (2.0.7)SEAMONKEY (2.0.7)Le projet SeaMonkey est issu d'un effort communautaire pour developper une application tout en un... Cliquez pour télécharger SeaMonkey Safari (5.0.2)SAFARI (5.0.2)Le navigateur d'Apple a lui aussi été mis à jour, aussi bien dans sa mouture Windows que celle po... Cliquez pour télécharger Safari Mozilla FireFox (4.0 béta 5)MOZILLA FIREFOX (4.0 BéTA 5)Firefox 4.0 béta 5
L'une des nouveautés visibles les plus attendues réside sans doute dans l'a... Cliquez pour télécharger Mozilla FireFox Mozilla Firefox (3.6.9)MOZILLA FIREFOX (3.6.9)Firefox 3.6.9 corrige les problèmes suivants :
* Introduced support for the X-FRAME-OPTION... Cliquez pour télécharger Mozilla Firefox
|