Discussion :

[alcibiade]

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]

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]

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]

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]

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]

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.