Discussion :

[warlock1968]

Bonjour,

Besoin d'aide

Il s’agit de réaliser une Applet affichant graphiquement une table de vérité, a partir d'une ligne de commande.

L'utilisateur saisie son équation (ex : (A . B)+C) et l'applet l'affiche sous forme de tableau.


Ce programme doit analyser l'expression entrée au clavier en utilisant l’algorithme de l’arbre, utiliser l‘algèbre de Boole et créer une table de vérité pour pouvoir l'afficher.

L‘analyse de l'expression ainsi que les notions de l'algèbre de Boole sont détaillées dans la partie “généralités”, et la partie "Descriptif du programme" qui explique aussi l'affichage de la table de vérité.

DESCRIPTIF DU PROGRAMME

Nous avons la classe appli-applet qui lance l'application .

=> mainframe, cadre 1, cadre1_aboutbox, cadre2_aboutbox.

Nous allons nous intéresser aux classes les plus importantes, Equation et EquationProcess.

Equation réalise la construction de l‘arbre, en effet, le constructeur Equation sépare la chaîne de saisie contenue dans StrEquation en branche (équation de droite et équation de gauche) a la rencontre d'un opérateur, ensuite on réapplique Equation sur les deux équations filles (gauche et droite) provenant de l'équation mère (équation de saisie) pour obtenir la récurssivité et ainsi construire l'arbre jusqu'aux feuilles.

On détecte les feuilles en testant si l'équation ne contient qu'un seul caractère.

Pour séparer une équation en deux parties, on fait appel a la méthode GetLeftEquation qui compte le nombre de parenthèses ouvertes et fermées afin de choisir le bon opérateur il y a hiérarchisation des opérateurs.

EX. : (A.B)+C on ne prend pas en compte le mais le. Mais le + car le nombre de parenthèses est égal a zéro .

Une fois qu'on a détecté le bon opérateur, les caractères précédents (qui ont été lus) forment l'équation de gauche. On utilise la méthode TrimPara pour supprimer les parenthèses de début et de fin de l‘équation de gauche.

Pour détecter l'opérateur on utilise la méthode CharAt dans le constructeur pour extraire l'opérateur de la chaîne de saisie, l'index de l'opérateur étant donné par la longueur de l‘équation de gauche. Les caractères d'après forment l’équation de droite à qui on applique la méthode TrimPara.

Pour l'opérateur unaire (la négation : !) on réalise un test dans le constructeur Equation pour le détecter, s'il s‘agit bien de cet opérateur, on modifie la valeur d'un booléen qui inversera le résultat de l'équation (dans ce cas il est a true). On indique l‘opérateur suivant a la Variable cOperator pour continuer l'arbre.

La méthode GetResult permet de calculer le résultat en fonction de l'opérateur (elle renvoie les exceptions nécessaire si l‘opérateur est non connue), on remonte ainsi l‘arbre en partant des feuilles. Cette méthode (GetResult) est utilisée dans la classe EqualionProcess pour afficher le résultat. La méthode Trim () qui utilise la classe ‘StringTokenizer' sert a effacer les espaces qui pourraient exister entre les variables et les opérateurs .

La classe EquationProcess est la deuxième classe importante du programme, elle se charge de construire la table de vérité et d‘afficher le résultat de “l'équation mère".

On définie tout d’abord en static une properties listVariableValues qui va contenir les propriétés des variables soit 0 ou 1.

On teste la longueur de la chaîne de saisie strEquation, Sl elle est égalé a O on renvoie un message d'erreur : “entrer une équation"

On construit un vecteur list qui va contenir toutes les variables tapées à la saisie. Pour cela on utilise la méthode GetAllVariable qui lie strEquation pour extraire (grâce a la méthode CharAt) uniquement les caractères. Le caractère lu doit être compris entre ’A' et ‘Z’.

Remarque on ne traite que les majuscules car on applique la méthode ToUpperCase

On utilise ensuite la méthode ExistInList pour savoir si le caractère existe déjà dans la list..


Afin de construire la table de vérité, on écrit la première ligne de la table de vérité :

A l B Il : solution, en fonction du nombre de variables saisies.

On crée ensuite la table de vérité de la taillé : (nbredevariables. strVariables)².str Variables Values va contenir les lignes (de gauche) de la table de vérité que l'on convertie en binaire grâce a la méthode ToBinaryString

EX : 2 = l O

Il faut ensuite rajouter des O. En effet si on a trois variables, pour la ligné numéro 2 on a 10 et nous on veut 010

Ensuite on lit ligne a ligne la table de vérité et on donne les propriétés aux Variables dans ListVariablesValues, celui-ci contient des true et false qu'on convertie en O et l dans StrReturn pour les afficher.

Enfin on applique GetResult à e (que l‘on défini comme étant équation e = new Equation), et on retourne le résultat dans StrReturn pour qu'il soit affiché dans le textfield.

[Pill_S]

tout ça pour.... ?

y'a-t-il une question précise qui découle de ton énoncé?

[warlock1968]

Enoncé du problème

Il s’agit de réaliser une Applet affichant graphiquement une table de vérité, a partir d'une ligne de commande.

L'utilisateur saisie son équation (ex : (A . B)+C) et l'applet l'affiche sous forme de tableau.

Ce programme doit analyser l'expression entrée au clavier en utilisant l’algorithme de l’arbre, utiliser l‘algèbre de Boole et créer une table de vérité pour pouvoir l'afficher.

[joel.drigo]

Salut,

Ça ne sert à rien de répéter l'énoncé déjà exposé dans ton premier message. Ce qu'on te demande c'est quelle question partiuclière as-tu concernant cet énoncé ? Quel problème t'empêche de réaliser ton programme ?

[warlock1968]

Bonjour, merci de m'aider

voici le code que j'ai écrit jusqu'à présent.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
 
package EquationResolver;
import java.util.*;
public class EquationProcess {
	String strEquation;
	String test;
	char erf;
	int nbrVariable;
	ArrayList listVariables;
	ArrayList listVariableValues;
	public EquationProcess(String in){
		if(in.length() == 0){
			System.out.println("erreur");
		}
		listVariables = new ArrayList();
		listVariableValues = new ArrayList();
		strEquation = in.trim();
		strEquation = strEquation.toUpperCase();
		GetAllVariable(strEquation);
	}
	/**
         * Rempli le vecteur listVariables avec les variables de l'équation saisie
         * @param eqa
         */
	void GetAllVariable(String eqa){
		int nbr = eqa.length();
		String tmp="";
		test = eqa;
		System.out.println("debut de boucle");
		System.out.println(nbr);
		for(int z=1;z>nbr;z++){
			System.out.println("merde");
			tmp = eqa.substring(z, z+1);
			System.out.println(z);
		}
		System.out.println("fin de boucle");
	}
	/**
         * Détermine si une variable est déja présente ou non
         * dans le vecteur.
         * @param varia variable à tester.
         * @return true si existe déja , false sinon
         */
	boolean ExistInList(char varia){
		return true;
	}
	/**
         * Transforme un entier en code binaire.
         * @param nbr entier à convertir
         * @return String mot binaire représentant l'entier.
         */
	String ToBinaryString(int nbr){
		String rbinaire = "";
		int reste;
		int nombre;
		if (nbr == 0){
			return rbinaire;
		}
		else{
			nombre = nbr;
			reste=0;
			while(nombre >1){
				reste = nombre % 2;
				nombre = nombre / 2;
				if(reste == 0){
					rbinaire = rbinaire + '0';
				}
				else{
					rbinaire = rbinaire + '1';
				}
			}
			if(nombre == 0){
				rbinaire = rbinaire + '0';
			}
			if(nombre == 1){
				rbinaire = rbinaire + '1';
			}
		}
		/*On inverse le mot binaire dans le bon sens */
		int nbrChar = rbinaire.length()-1;
		String retour="";
		for(int j=nbrChar;j>=0;j--){
			retour += rbinaire.charAt(j);
		}
		return retour;
	}
	public static void main(String[] args){
		int nbr = 1000000;
		EquationProcess moi = new EquationProcess("bla bla");
		String out = moi.ToBinaryString(nbr);
		System.out.println(out);
		System.out.println(moi.listVariables.toString());
		System.out.println(moi.listVariables.size());
		System.out.println(moi.test);
		System.out.println(moi.erf);
		System.out.println(moi.strEquation);
		/*for(int i=1;i>moi.listVariables.size()+1;i++){
			System.out.println(moi.listVariables.elementAt(i));
		}*/
	}
}

Je doit réaliser une applet, qui à partir d'une équation va généré une table de vérité de l'équation.

On m'indique dans le sujet divers méthode à faire mais ça ne m'aide pas trop, je sais juste que je doit avoir deux classes particulières , Equation et EquationProcess , qui calcule le résultat et affiche la table de vérité.

De plus de quelle façon graphique créer cet applet ( je suis débutant).

[joel.drigo]

Débutant comment ? Tu n'as jamais fait d'interface graphiqe Swing ou si, un peu quand même ? Parce que si tu as déjà fait un peu de Swing (ou d'AWT), tu pourras facilement faire une applet, puisque le composant JApplet (ou Applet pour AWT) est un composant graphique avec quelques trucs en plus (déjà comment faire pour qu'elle s'affiche dans un html).

Tu as un tutoriel ici. Il y en a d'autres dans la section Tutoriels.

Si tu n'as jamais fait de Swing du tout, il te faudra déjà savoir comment afficher ton résultat dans un panneau (JPanel) lui-même dans une fenêtre (JFrame). Pour ça aussi, tutoriel ici, ou d'autres dans la section Tutoriels.

Cela dit je me pose la question du pourquoi faire une applet (technologie plutôt obsolète, et devenant de plus en plus compliqué à faire fonctionner dans les navigateurs modernes qui l'en empêchent pour éviter les intrusions en particulier).