[Débutant] Problème de logique avec Java

**alcibiade** · 21/08/2011, 04h51

Bonjour,

J'ai un problème concernant un petit programme dans mon cours.
Ça concerne la logique et plus précisément le connecteur implique.

Voici donc la table du connecteur en question:

vrai vrai implique vrai
vrai faux implique faux
faux vrai implique vrai
faux faux implique vrai

Il y a ces deux fonctions dans mon cours que je ne comprends pas, le tout n'est pas compliqué mais j'aimerais bien comprendre les voici :

Première fonction

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
static boolean Implique(boolean a, boolean b)
{
    if (a) {
        if (b) {
            return true;
        }
        else {
            return false;
        }
    }
    else {
        return true;
    }
}

Deuxième fonction

Code :

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

1
2
3
4
static boolean Implique2(boolean a, boolean b) 
{
   return (!a) || b;
}

Pour la première méthode j'ai compris :

Si a est vrai et si b est vrai alors VRAI.
Sinon tu retournes FAUX.

Mais c'est tout ce que j'ai compris et je n'ai rien compris par contre pour la deuxième. De plus, je ne comprends pas comment avec aussi peu de conditions on arrive à explorer toutes les possibilités ?

Merci d'avance pour vos éclaircissements.

**rtg57** · 21/08/2011, 07h47

Bonjour,

c'est de l'algèbre de Boole: http://fr.wikipedia.org/wiki/Alg%C3%...oole_(logique)

regardez le tableau concernant la fonction OU: Le résultat vaut 0 c'est à dire False pour les entrées a et b valant False. Ce qui se traduit en équation d'algèbre de Boole: S = a + b ou en langage informatique: S = a || b
Si l'on traduit cela en règle, on obtient False; False implique False.
Ce qui signifie en logique: a = False; b = False implique S = False.

Or on vous demande une règle disant True; False implique False.
Il s'avère que cela ressemble à l'équation du OU logique, avec comme différence: l'inversion de l'entrée a, c'est à dire en algèbre de Boole Pas a, c'est à dire en langage informatique: !a

D'où l'équation !a || b = S

L'avantage de ce genre d'équation est que vous parlez directement au µProcesseur dans un langage qu'il connait.
Alors que chercher le même résultat en alignant une suite de if else fait perdre beaucoup de temps à la machine ( sans entrer dans le détail, à cause de la prédiction de branchement du µP)
Malheureusement, il n'est pas évident de penser à traduire une suite de conditions, en équation algébrique

J'espère que je ne suis pas hors sujet

**kolodz** · 21/08/2011, 10h13

On peut tenter simplement d'obtenir seulement le cas à séparer qui donne faux :

Code :

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

1
2
3
4
5
6
7
static boolean Implique3(boolean a,boolean b)
{
     if(a && !b){
          return false;
     }
     return true;
}

Et avec un peut de chance l'inverse de ( a&&!b) se trouve être !a||b.
Théorème de De Morgan dont pratiquement aucun informaticien n'arrive à appliquer...

Cordialement,
Patrick Kolodziejczyk.

Edit démonstration :
!(a&&!b)=!a||!(!b)=!a||b

**alcibiade** · 22/08/2011, 00h06

Merci avant tout pour ses réponses.

Je commence un peu mieux à comprendre. Déjà, je trouve que l'implication et ou, se ressemble. Ce que je trouve intéressant dans ces exemple c'est surtout l'élégance du code. Avez vous justement des livres plus détaillé sur ce sujet. Je ne parle pas vraiment de cours de logique mais plus, d'une manière de bien coder en utilisant ces concept.
Merci

**alcibiade** · 22/08/2011, 03h50

Voici quelques essais de codage de certaines table ET OU OUX qui est le ou exclusif et EQ équivalent. Je n'ai pas fait le implique vu que nous l'avons déjà vu. Pouvez vous me dire sur quoi je peux m'améliorer ? Le EQ me semble assez lourd ... Y' a t' il une méthode plus élégante ?

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
 
public class Table {
 
	static boolean ET(boolean a,boolean b)
	{
		return a && b;
	} 
 
	static boolean OU(boolean a,boolean b)
	{
		return a || b;
	}
 
	static boolean OUX(boolean a,boolean b)
	{
		if(!a && !b) return false;
		else
		    return !(a && b);
	}
 
	static boolean EQ(boolean a,boolean b)
	{
		return (!OUX(a,b));
	}
 
	public static void main(String []args)
	{
		boolean a,b;
		a=true;
		b=true;
 
		System.out.println("V ET V = "+ ET(a,b));
		System.out.println("V ET F = "+ ET(a,!b));
		System.out.println("F ET V = "+ ET(!a,b));
		System.out.println("F ET F = "+ ET(!a,!b));
		System.out.println("*********************");
		System.out.println("V OU V = "+OU(a,b));
		System.out.println("V OU F = "+OU(a,!b));
		System.out.println("F OU V = "+OU(!a,b));
		System.out.println("F OU F = "+OU(!a,!b));
		System.out.println("*********************");
		System.out.println("V OUX V = "+OUX(a,b));
		System.out.println("V OUX F = "+OUX(a,!b));
		System.out.println("F OUX V = "+OUX(!a,b));
		System.out.println("F OUX F = "+OUX(!a,!b));
		System.out.println("*********************");
		System.out.println("V V EQUIVAUT a "+EQ(a,b));
		System.out.println("V F EQUIVAUT a "+EQ(a,!b));
		System.out.println("F V EQUIVAUT a "+EQ(!a,b));
		System.out.println("F F EQUIVAUT a "+EQ(!a,!b));
	}
 
}

Merci encore

**kolodz** · 22/08/2011, 06h16

Il est préférable de ne pas utiliser de fonction lors qu'il existe des opérateurs pour ce type d'opération :

Code :

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

1
2
3
4
5
6
7
8
9
boolean a,b,c;
//Réalisation d'un ET
c =  a && b;
//Réalisation d'un OU
c = a || b;
// Réalisation de XOR = ou exclusif
c = a ^ b;
// Réalisation d'une égalité
c = a ==b;

Cordialement,
Patrick Kolodziejczyk.

**rtg57** · 23/08/2011, 07h44

Bonjour,

il y a aussi une astuce pour mettre 0 dans une variable; elle est surtout utilisée en langage assembleur:
a = a XOR a, c'est le OU Exclusif
En JAVA et C, cela donne:
a ^= a;, au lieu de a = 0;
L'avantage de cette syntaxe est qu'elle exécute ceci telque en langage machine, elle est très courte et n'a pas besoin d'aller charger la valeur '0' inscrite en mémoire.
Mais peut être que la JVM interprète d'elle-même ceci...

C'était juste pour participer un peu

**Mopmop** · 23/08/2011, 08h59

Envoyé par rtg57

L'avantage de cette syntaxe est qu'elle exécute ceci telque en langage machine, elle est très courte et n'a pas besoin d'aller charger la valeur '0' inscrite en mémoire.
Mais peut être que la JVM interprète d'elle-même ceci...

C'était juste pour participer un peu

T'es sûr que c'est plus efficace ? Parce que selon moi la machine va charger deux fois "a" (une fois dans deux registres différents) et donc ça ne me parait pas plus rapide que d'aller chercher un pauv' zéro... Sauf si la JVM est bien optimisée et que "a" n'est chargé qu'une fois (mais ça ne me parait pas évident comme optimisation)

De plus, si je ne me trompe pas, le xor "^" est un opérateur bit à bit donc si ton "a" est un peu grand j'ai des doutes sur l'efficacité de la méthode...

Le problème c'est que je dis tout ça sans grande certitude alors si certains peuvent confirmer/infirmer nos dires, je suis preneur

**rtg57** · 24/08/2011, 11h39

Bonjour,

lorsque vous écrivez en langage assembleur:
a = 0 (a étant un registre du µProcesseur), un compilateur C++ interprètera ce code et le transformera en:
a = a XOR a
Vous pouvez faire confiance au compilateur...il choisit souvent le meilleur code possible. Alors peut être que l'interpréteur JAVA fait cela de lui-même...
De plus, l'instruction Registre = Registre XOR Registre fait partie des instructions câblées électroniquement des µProcesseurs. Notamment celle-ci sera exécutée en 1 seul cycle d'horloge.
Mais ceci ne rentre pas trop dans le sujet d'un forum JAVA.
JAVA est un langage orienté objet, pour lequel ont ne recherche pas forcément un gain en nanoseconde

Cela ne doit pas nous empêcher de proposer du code rapide et efficace.

**Mopmop** · 24/08/2011, 16h52

En effet la différence doit être vraiment minime... de toutes façon je compte garder mon a = 0, ça reste selon moi plus lisible.

Mais bon, des fois qu'un jour je tombe sur un cas ou il faut que je gagne des pets de mouche, j'y penserais

**Uther** · 25/08/2011, 08h46

Envoyé par rtg57

Bonjour,

il y a aussi une astuce pour mettre 0 dans une variable; elle est surtout utilisée en langage assembleur:
a = a XOR a, c'est le OU Exclusif
En JAVA et C, cela donne:
a ^= a;, au lieu de a = 0;

Ca ressemble a une vieille ruse de sioux qui n'aura probablement pas l'effet escompté a part sur certains couples compilateurs / processeurs particuliers.

La plupart des processeurs ont des instructions de chargement de constantes prévues pour, qui seront au moins aussi rapide qu'un XOR. Si le compilateur n'est pas mauvais, il devrait savoir utiliser ça.
Et encore plus particulièrement Java, mieux vaut ne pas essayer de deviner ce que va compiler le JIT, il n'y a aucune règle officielle et ça pourrait changer d'une version à l'autre(d'ailleurs le JIT lui même n'est pas une obligation).

**tchize_** · 25/08/2011, 23h09

Envoyé par Uther

Ca ressemble a une vieille ruse de sioux qui n'aura probablement pas l'effet escompté a part sur certains couples compilateurs / processeurs particuliers.

Ca date de l'époque des 386 etc où
XOR AX,AX
et similaires prenait très peut de taille sur la pile d'instruction (de mémoire 1 byte), contrairement à
MOV AX,0
qui nécessitait au moins l'instruction + un mot contenant la valeur à charger, bref 5 bytes à lire par le processeur.

Ca n'a plus aucun intérêt aujourd'hui.

**rtg57** · 26/08/2011, 06h29

Bonjour,

effectivement, l'astuce XOR n'a pas d'intérêt en JAVA je pense.
Avec ce langage, on recherche autre chose que grapiller du cycle horloge.
Sinon, on va dans le forum concernant l'assembleur

**fallo** · 04/09/2011, 12h49

juste un point :

tu dis:
Pour la première méthode j'ai compris :

Si a est vrai et si b est vrai alors VRAI.
Sinon tu retournes FAUX.

Mais c'est tout ce que j'ai compris et je n'ai rien compris par contre pour la deuxième. De plus, je ne comprends pas comment avec aussi peu de conditions on arrive à explorer toutes les possibilités ?

-----
en fait ta deuxieme ligne "sinon tu retournes faux" est hors contexte. je m'explique :

tu a un tableau qui dit
- vrai & vrai => vrai <-> Si a est vrai et si b est vrai alors VRAI. (ca ne veux pas dire que sinon tu retournes faux en fait on dit vrai et vrai implique vrai, mais on n'expose aucune autre implication ( ce que signifie ton sinon ) )
- vrai & faux => faux <-> Si a est vrai et si b est faux alors FAUX.
- faux & vrai => vrai<-> Si a est faux et si b est vrai alors vrai.
- faux & faux => vrai<-> si a est faux et si b est faux alors vrai.

la methode pour analyser ceci est la suivante : tu rassemble les choses qui deviennent vrai en un bloc et tu fais des groupes (la methode sur papier se fait avec ligne versus colonnes (avec des 0 et des 1 pour la lisibilité si tu as beaucoup d'implications) :
- faux & vrai => vrai<-> Si _a est faux_ et si b est vrai _alors _vrai_.
- faux & faux => vrai<-> si _a est faux_ et si b est faux alors _vrai_.
- vrai & vrai => vrai <-> Si _a est vrai et si b est vrai_ alors _vrai_.
on voit donc apparaitre un premier groupe : si a est faux alors vrai ( !a )
il reste un autre groupe qui dit qu'il faut que a et b soit vrai (a && b)
donc cela donne !a || (a&&b)
comme le OU (||) est interpreté que si la branche de gauche est fausse, on sait que a droite la valeur de a est true. et qu'on sait true && b equivaux a b (propriété de &&) ( attention rien a voir avec l'ordre des opérations autour du ou, bien que c'est parfois plus facile a comprendre visuellement)
cela se simplifie donc en !a || b.
j'ai orienté les groupes pour mettre celui du !a en premier, car c'est le plus gros

en esperant que ca serve a comprendre la logique.

et ++ pour l'emplois des opérateurs ainsi que des affectations claires.

**alcibiade** · 09/09/2011, 23h26

Merci beaucoup pour vos réponses, cela fait très longtemps que je n'ai pas été sur le forum. Merci en tout cas je termine donc par un beau résolu.

[Débutant] Problème de logique avec Java

avec Java

Discussions similaires

Partager

Partager