|
|
Interprète d'expressions logiques
On doit représenter les propositions logiques et effectuer un
certain nombre de traitements sur celles-ci, par exemple, les évaluer,
les imprimer de façon infixe, ou suffixe, etc.
Une proposition est
- soit un atome,
- soit la conjonction de deux propositions,
- soit la disjonction de deux propositions,
- soit la négation d'une proposition ;
Un atome exprime l'énoncé d'un fait (vrai ou faux), par exemple "La
mer est grise", que l'on représente par une chaîne de caractères.
On transcrit cette définition en une hiérarchie de classes : la classe
parente est une classe abstraite Prop, ses classes dérivées
sont des classes concrètes Atome, Conj, Disj
et Neg. Par exemple, on devra pouvoir écrire :
Prop p = new Disj(new Atome("La mer est grise"),
new Neg(new Atome("le temps est calme")))
-
Transcrire cette grammaire en Java en définissant
des types Prop, Atome,
Conj, Disj et Neg. Pour
l'instant, on indiquera seulement la relation d'extension entre ces
différents types, leurs champs et les constructeurs assurant
l'initialisation des champs. Les champs de ces classes seront privés.
- La méthode public String toString() permet d'obtenir la
représentation d'un objet quelconque par une chaîne de caractères. On
souhaite redéfinir cette méthode de sorte que, par exemple, la
proposition (p et non q) ou r soit représentée par la chaîne
((p&(~q))|r), si p, q, et r sont des atomes représentant
les faits "p", "q" et "r". L'expression
textuelle obtenue doit être complètement parenthésée, comme sur cet exemple.
Redéfinir la méthode toString dans chacune des classes
Atome, Conj, Disj et Neg.
Tester cette méthode en imprimant sur System.out la
proposition non (a et non(b ou non non c)), définie dans la
fonction main.
-
La valeur de vérité d'une proposition peut être calculée dès que la
valeur de vérité de chacun des atomes qu'elle contient est connue. On
représente une valeur de vérité par une valeur de type boolean.
Ajoutez un champ valeur au type Atome et
modifier son constructeur en conséquence.
Déclarer une méthode évaluer dans la classe Prop et
l'implémenter dans chacune des autres classes afin de calculer la
valeur de vérité d'une proposition quelconque.
Tester cette méthode dans la fonction main, sur la même
proposition, par exemple si a faux, b et c vrais.
Ajouter à chacune de ces classes les méthodes prédicats (testant si
une proposition est un atome, si elle est une conjonction, etc.).
Une proposition est en forme normale négative
(fnn) si la négation est
appliqué seulement aux atomes. La fnn est obtenue en "rentrant" les
négations à l'intérieur des conjonctions et des disjonctions par
application des règles
non(p et q) --> (non p) ou (non q)
non(p ou q) --> (non p) et (non q)
non(non p) --> p
Déclarer une méthode fnn dans la classe Prop et
l'implémenter dans chacune des autres classes afin de calculer la
fnn d'une proposition quelconque.
Tester cette méthode dans la fonction main, toujours sur
la même proposition.
|