ENSEMBLE COMPLEXE

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;
		}
	}
}