Algorithmique TD5 Axiomes

Ex 1

Q1)
TYPE ABSTRAIT Liste
Opérations de base
Constructeur Liste : listeVide() : Liste
Transformateur Liste : ajouter(Element e) : Liste
Observateur Liste : reste() : Liste (par référence)
Observateur Liste : tete() : Element
Observateur Liste : estVide() : Booleen
Fin des opérations de base
Préconditions
definie(l.tete()) ==> non l.estVide()												
// L'opération tete ne peut être utilisée que si la liste n'est pas vide
definie(l.reste()) ==> non l.estVide()												
// L'opération reste ne peut être utilisée que si la liste n'est pas vide
Axiomes
listeVide().estVide()
// Liste vide à la construction
non l.ajouter(e).estVide()
// Quand on ajoute un élément à la liste alors la liste n'est plus vide
l.ajouter(e).tete() = e
// Si on ajoute un nouvel élément à la liste alors il correspond à la tete de la nouvelle liste
l1 = l.copie() ==> l.ajouter(e).reste().estEgal(l1)
// Si on ajoute un élément à la liste alors le reste de la nouvelle liste est égal à l'ancienne liste							

Q2)
Si on veut être sur d’avoir tous les axiomes : il faut prendre tous les constructeurs et observateurs et on regarde leur valeur à la fin pour voir si ça marche
consi.obsj => 3 axiomes
transi.obsj => 3 axiomes
transi.transj => 1 axiome
•	Il manque des axiomes

On ne peut pas utiliser ListeVide.reste et ListeVide.tete car ils sont traités dans les pré-conditions
•	On a bien aussi les 3 pour trans.obs
Le seul qu’il manquerait serait ajouter.ajouter
l.ajouter(e1).ajouter(e2).tete()=e2	=> là c’est redondant, on retombe sur des axiomes déjà existant

Q3)
l <-- listeVide()
l.ajouter(e1)
l.ajouter(e2)
l.ajouter(e3)

L = listeVide().ajouter(e1).ajouter(e2).ajouter(e3)
3ème élément de la liste  récupérer la tête du 2ème reste
 listeVide().ajouter(e1).ajouter(e2).ajouter(e3).reste().reste().tete()
Si on pose L0 = listeVide().ajouter(e1).ajouter(e2)
On obtient S = L0.ajouter(e3).reste().reste().tete()
Or le 4ème axiome nous donne :
S = L0.reste().tete()
De même, si on pose L1 = listeVide().ajouter(e1)
on obtient S = L1.tete() = listeVide().ajouter(e1).tete()
Or d’après l’axiome 3 on a 
S = e1

Ex 2

Q1)
L'ensemble des polynômes A[X] est définie par
• { P(X) = a0 + a1 X + ... + an X n / ai Î R }
Définir un type abstrait qui permet :
• de définir un polynôme en connaissant ces coefficients		// base (constructeur)
• de définir la dérivée formelle d'un polynôme formel donné	// extension (observateur)
• de récupérer le degré du polynôme					// base (observateur)
• de récupérer la valeur de n'importe quel coefficient		// base (observateur)
• de changer la valeur de n'importe quel coefficient			// base (transformateur)
• de récupérer la valeur du polynôme pour une valeur x de X	// extension

Q2)
TA Polynome
Opérations de base :
	Constructeur Polynome : creerPolynome(p : Vecteur) : Polynome
	Observateur Polynome : recDegré() : Entier
	Observateur Polynome : recCoeff(i : Entier) : Reel
	Transformateur Polynome : affCoeff(i : Entier, e : Reel) : Polynome
Pré-conditions :
	definie(p.recCoeff(i))  0 <= i <= p.recDegré()
	definie(p.affCoeff(i,e))  0 <= i <= p.recDegré()
	definie(creerPolynome(v))  v.borneInf() >= 0
Axiomes :
	creerPolynome(v).recDegre() = v.borneSup()
	creerPolynome(v).recCoeff(i) = v.recVal(i)
	p.affCoeff(i,e).recCoeff(i) = e