Ensemble complexe
Contenu du snippet
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.
Si vous trouvez des erreurs, dites le moi. Si vous ne comprenez pas certains points du code, dites moi, je commenterai plus spécifiquement.
Source / Exemple :
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.
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.