Gestion des nombres complexes

Télécharger le projet
Commenter

Description

Cette source permet de définir un ensemble d'objets permettant de gérer les nombres complexes.

Une classe mère AbstractComplexe définit les méthodes utilisables pour les nombres complexes et deux classes filles ComplexePolaire et ComplexeCarthésien implémentent cette classe mère.

Les deux classes filles permettent de définir le nombre complexe soit en notation carthésienne : a+bi soit en notation polaire ro*exp(teta). Les deux classes filles possèdent les mêmes méthodes implémentées différemment en fonction de la représentation du nombre complexe.

Pour bien utiliser ce code, il faut penser à utiliser le polymorphisme : Il faut toujours déclarer les nombres complexes comme des AbstratComplexe :
AbstractComplexe c1 = new ComplexePolaire(2, 2);
et non ;
ComplexePolaire c1 = new ComplexePolaire(2, 2);

Source / Exemple : 


package fr.julien.complexes;

/**


     
  •  <b>AbstractComplexe est la classe qui définit un nombre complexe quel que soit son système de notation</b>

    •  
  •  <p>

    •  
  •  Cette classe ne contient aucun attribut.

    •  
  •  </p>

    •  
  •  <p>

    •  
  •  Elle permet de définir les méthodes abstraites permettant de :

    •  
  •  <ul>

    •  
  •  <li>ajouter des nombres complexes</li>

    •  
  •  <li>multiplier des nombres complexes</li>

    •  
  •  <li>récupérer le conjugé d'un nombre complexe</li>

    •  
  •  <li>récupérer la partie réeelle du nombre complexe</li>

    •  
  •  <li>récupérer la partie imaginaire du nombre complexe</li>

    •  
  •  <li>récupérer le module du nombre complexe</li>

    •  
  •  <li>récupérer l'argument du nombre complexe</li>

    •  
  •  <li>afficher le nombre complexe</li>

    •  
  •  </ul>

    •  
  •  Cette classe implémente également des méthodes permettant de :

    •  
  •  <ul>

    •  
  •  <li>définir la notation carthésienne du nombre complexe</li>

    •  
  •  <li>définir la notation vectorielle carthésienne du nombre complexe</li>

    •  
  •  <li>définir la notation vectorielle polaire du nombre complexe</li>

    •  
  •  <li>définir la notation trigonométrique du nombre complexe</li>

    •  
  •  <li>définir la notation géométrique du nombre complexe</li>

    •  
  •  <li>définir la notation matricielle du nombre complexe</li>

    •  
  •  <li>normaliser les sorties lors de l'affichage</li>

    •  
  •  </ul>

    •  
  •  </p>

    •  
  •  <p>

    •  
  •  Cette classe contient un attribut static : LETTRE_COMPLEXE qui permet de

    •  
  •  définir la lettre utilisée pour la définition de la partie imaginaire des 

    •  
  •  nombres complexes. Par défaut, cette valeur est i.

    •  
  •  </p>

    •  
  •  <p>

    •  
  •  Dans cette classe, deux variables permettent de définir les nombres complexes i

    •  
  •  de partie réelle nulle et de partie imaginaire 1. Et le nombre complexe J tel que

    •  
  •  1 + j + j*j = 0  

    •  
  •  </p>

    •  
  •  

    •  
  •  @author Julien

    •  
  •  @version 1.0

 *


     
  • /

public abstract class AbstractComplexe {
	
	/**


    	 
  •  Le nombre complexe i Re(i)=0 et Im(i)=1

    • 	 
  • /

	public static final AbstractComplexe I = new ComplexeCarthesien(0, 1);
	
	/**


    	 
  •  Le nombre complexe j tel que 1 + j + j*j = 0

    • 	 
  • /

	public static final AbstractComplexe J = new ComplexeCarthesien(-0.5, -Math.sqrt(3)/2);
	
	/**


    	 
  •  La lettre utilisée pour définir la partie imaginaire en notation carthésienne

    • 	 
  • /

	public static String LETTRE_COMPLEXE = "i";
	
	/**


    	 
  •  Fonction permettant d'ajouter des nombres complexes

    • 	 
  •  @param c

    • 	 
  •  	Le nombre complexe à ajouter

    • 	 
  •  @return la somme de c et du nombre complexe courant

    • 	 
  • /

	public abstract AbstractComplexe ajouter(final AbstractComplexe c);
	
	/**


    	 
  •  Fonction permettant de multiplier des complexes

    • 	 
  •  @param c

    • 	 
  •  	Le nombre complexe auquel nous allons multiplier this

    • 	 
  •  @return le produit de c et du nombre complexe courant

    • 	 
  • /

	public abstract AbstractComplexe multiplier(final AbstractComplexe c);
	
	/**


    	 
  •  Méthode permettant de calculer le conjugé du nombre complexe courant

    • 	 
  •  @return le conjuge du nombre complexe courant

    • 	 
  • /

	public abstract AbstractComplexe conjuge();
	
	/**


    	 
  •  Méthode permettant de récupérer la partie réelle du nombre complexe

    • 	 
  •  @return la partie réelle du nombre complexe

    • 	 
  • /

	public abstract double getReel();
	
	/**


    	 
  •  Méthode permettant de récupérer la partie imaginaire du nombre complexe

    • 	 
  •  @return la partie imaginaire du nombre complexe

    • 	 
  • /

	public abstract double getImaginaire();
	
	/**


    	 
  •  Méthode permettant de retourner le module du nombre complexe

    • 	 
  •  @return le module du nombre complexe

    • 	 
  • /

	public abstract double getRo();
	
	/**


    	 
  •  Méthode permettant de calculer l'argument du nombre complexe

    • 	 
  •  @return l'argument du nombre complexe

    • 	 
  • /

	public abstract double getTeta();
	
	/**


    	 
  •  Fonction permettant de calculer le module du nombre complexe

    • 	 
  •  @return le module du nombre comlexe

    • 	 
  • /

	public final double module(){
		return Math.sqrt(getReel()*getReel()+getImaginaire()*getImaginaire());
	}
	
	/**


    	 
  •  Fonction permettant de récupérer la notation algébrique du nombre complexe

    • 	 
  •  @return la notation algébrique du nombre complexe

    • 	 
  • /

	public final String notationAlgébrique(){
		StringBuilder sb = new StringBuilder();
		if(getReel()!=0){
			if(getImaginaire()!=0){
				sb.append(normaliser(getReel()));
				if(getImaginaire()>0){
					sb.append(" + ");
				}
				else if(getImaginaire()<0) {
					sb.append(" - ");
				}
				if(Math.abs(getImaginaire())!=1){
					sb.append(normaliser(Math.abs(getImaginaire())));
				}
				sb.append(LETTRE_COMPLEXE);
			}
			else {
				sb.append(normaliser(getReel()));
			}
		}
		else {
			if(getImaginaire()!=0){
				if(Math.abs(getImaginaire())!=1){
					sb.append(normaliser(getImaginaire()));
				}
				if(getImaginaire()==-1){
					sb.append("-");
				}
				sb.append(LETTRE_COMPLEXE);
			}
			else {
				sb.append("0");
			}
		}

		return sb.toString();
	}
	
	/**


    	 
  •  Fonction permettant de récupérer la notation vectorielle carthésienne du nombre complexe

    • 	 
  •  @return la notation vectorielle carthésienne du nombre complexe

    • 	 
  • /

	public final String notationVectorielleCarthesienne(){
		return "("+normaliser(getReel())+", "+normaliser(getImaginaire())+")";
	}
	
	/**


    	 
  •  Fonction permettant de récupérer la notation vectorielle polaire du nombre complexe

    • 	 
  •  @return la notation vectorielle polaire du nombre complexe

    • 	 
  • /

	public final String notationVectoriellePolaire(){
		return "("+normaliser(getRo())+", "+normaliser(getTeta())+")";
	}
	
	/**


    	 
  •  Fonction permettant de récupérer la notation trigonométrique du nombre complexe

    • 	 
  •  @return la notation trigonométrique du nombre complexe

    • 	 
  • /

	public String notationTrigonometrique(){
		return normaliser(getRo())+"(cos("+normaliser(getTeta())+") + "+LETTRE_COMPLEXE+"cos("+normaliser(getTeta())+")";
	}
	
	/**


    	 
  •  Fonction permettant de récupérer la notation géométrique du nombre complexe

    • 	 
  •  @return la notation géométrique du nombre complexe

    • 	 
  • /

	public String notationGeometrique(){
		StringBuilder sb = new StringBuilder();
		if(getRo()!=0){
			if(getRo()!=1){
				sb.append(normaliser(getRo()));
			}
			if(getTeta()%2*Math.PI!=0){
				sb.append("exp(");
				if(getTeta()!=1 && getTeta()!=-1){
					sb.append(normaliser(getTeta()));
				}
				if(getTeta()==-1){
					sb.append("-");
				}
				sb.append(LETTRE_COMPLEXE);
				sb.append(")");
			}
		}
		else {
			sb.append("0");
		}
		return sb.toString();
	}
	
	/**


    	 
  •  Fonction permettant de récupérer la notation matricielle du nombre complexe

    • 	 
  •  @return la notation matricielle du nombre complexe

    • 	 
  • /

	public String notationMatricielle(){
		StringBuilder sb = new StringBuilder();
		sb.append("| ");
		sb.append(normaliser(getRo()));
		sb.append(" ");
		sb.append(0);
		sb.append(" ");
		sb.append("| | ");
		sb.append("cos(");
		sb.append(normaliser(getTeta()));
		sb.append(") ");
		sb.append("-sin(");
		sb.append(normaliser(getTeta()));
		sb.append(") |\n");
		sb.append("| ");
		sb.append(0);
		sb.append(" ");
		sb.append(normaliser(getRo()));
		sb.append(" ");
		sb.append("| | ");
		sb.append("sin(");
		sb.append(normaliser(getTeta()));
		sb.append(") ");
		sb.append("cos(");
		sb.append(normaliser(getTeta()));
		sb.append(") |");
		return sb.toString();
	}
	
	/**


    	 
  •  Fonction permettant de normaliser les sorties pouir l'affichage

    • 	 
  •  @param d

    • 	 
  •  	La valeur à afficher

    • 	 
  •  @return la sortie normalisée (les .00 ont été supprimés)

    • 	 
  • /

	public final String normaliser(final double d){
		return (d+"").replaceAll("\\.0+$", "");
	}

}
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_Julien39)