Fork: 0
x-way / ai
Browse code
Added lab6 skel files
master
1 parent 98a5f3b commit 210cbfdb8a336f1f1311be7bcf50fee7499120df
@Andreas Jaggi Andreas Jaggi authored on 1 May 2006
x-way committed on 1 May 2006
Patch
Unified Split
Showing 4 changed files
View
180
■■■■■
 lab6/PSC.py 0 → 100644
import libPSC
import copy
#################################################################################
print "Chargement du module PSC"
print "\t@version: 1.1 date: 24/04/2006 modified by the vincent.schickel-zuber@epfl.ch"
print "\t@author: vincent.schickel-zuber@epfl.ch date: 24/04/2006"
print "\t@copyright: EPFL-IC-IIF-LIA 2006"
#################################################################################
 
##contient tous les noeuds
NOEUDS=[]
 
##contient tous les arcs
ARCS=[]
 
##valeur retournee en cas d'echec
ECHEC='echec'
 
##contient le nombre d'iteration de l'algorithme
ITERATION = 0
 
##contient les solutions de l'algorithme
SOLUTION=[]
 
##retourne toutes les contraintes unaires pour un noeud donnne
##@param noeud le noeud
def retourneContraintesUnaires(noeud):
contraintes=[]
for a in ARCS:
if a.refContrainte.depart==noeud.refVar and a.refContrainte.arrive==noeud.refVar:
contraintes.append(a.refContrainte)
return contraintes
 
##retourne toutes les contraintes binaires pour deux noeuds donnnes
##@param noeud1 le noeud 1
##@param noeud2 le noeud 2
##@ret toutes les contraintes bineaires ente n1 et n2
def retourneContraintesBinaires(noeud1,noeud2):
contraintes=[]
for a in ARCS:
if (a.refContrainte.depart==noeud1.refVar and a.refContrainte.arrive==noeud2.refVar) or (a.refContrainte.depart==noeud2.refVar and a.refContrainte.arrive==noeud1.refVar):
if a.refContrainte not in contraintes:
contraintes.append(a.refContrainte)
return contraintes
 
 
 
##affiche la solution avec queques informations utile
##@param algo le nom de l'algo
##@param solution la solution trouvee
def afficheSolution(algo,solution):
print "\t",algo,": SOLUTION TROUVEE en ",ITERATION,"etapes et avec ",libPSC.NBCONTRAINTE," contraintes verifiees; SOLUTION=",solution
 
##affiche le nombre d'iteration avec queques informations utile
##@param algo le nom de l'algo
##@param k la pronfondeur actuelle
def afficheNbIteration(algo,k):
print algo,": Ieration:=",ITERATION," pronfondeur actuelle:=",k ,"et",libPSC.NBCONTRAINTE," contraintes verifiees"
##gere tous les noeuds dans NOEUDS
class Noeuds:
 
##initialise le tableau de noeuds
def __init__(self):
NOEUDS=[]
 
##retourne le noeud referencant le variable ayant un nom=nom
##@param nom le nom de la variable
##@ret le noeud, -1 si pas trouvée
def retourneNoeud(self, nom):
for noeud in NOEUDS:
if noeud.refVar.nomEstEgalle(nom):
return noeud
return -1
 
##ajoute un noeud a la lite
def ajouteNoeud(self,noeud):
NOEUDS.append(noeud)
 
##applique la consitance des noeuds
def consistanceDesNoeuds(self):
for n in NOEUDS:
n.consitanceDuNoeud(A COMPETER);
 
##affiche tous les noeuds
def __str__(self):
str = "Noeuds\n"
for n in NOEUDS:
str+="\t1. "+ n.__str__()+"\n"
return str
 
 
##gere tous les noeuds dans ARCS
class Arcs:
 
##initialise le tableau des ARCS
def __init__(self):
ARCS=[]
 
##ajoute un arc a la lite
def ajouteArc(self,arc):
ARCS.append(arc)
 
##retourne tous les arcs unaire pour un noeud donnne
##@param noeud le noeud
def retourneArcs(noeud):
arcs2
for a in ARCS:
if a.refContrainte.depart==noeud.refVar and a.refContrainte.arrive==noeud.refVar:
arcs2.append(a)
return arcs2
 
##applique la consitance des arcs
def consistanceDesArcs(self):
.... A FAIRE
 
##affiche tous les noeuds
def __str__(self):
str = "Arcs\n"
for n in ARCS:
str+="\t1. "+ n.__str__()+"\n"
return str
 
## Algorithme de Bactrack simple
## @param instances les n variables; rempli jusqu'a k
## @param k la pronfondeur de la recherce (commence a 0)
## @param toutesLesSolutions si True alors cherche TOUTES les solutions, sinon s'arrete a la premiere (valeur oar defaut)
## @param initialise initialise les variables gloabl ITEARTION et SOLUTION
## @ret instances contenant la solution OU echec si aucune solution trouvée
def backtrack(instances, k, touteLesSoltuions=None, initialise=None):
algo="bt"
global ITERATION
global SOLUTION
if touteLesSoltuions==None:
touteLesSoltuions=False
if initialise==None:
ITERATION=0
SOLUTION=[]
libPSC.NBCONTRAINTE=0
initialise=False
ITERATION=ITERATION+1
 
print "....."
afficheSolution(algo,instances)
print "....."
 
return ECHEC
 
 
## Algorithme de Forward Chekcing simple
## @param instances les n variables; rempli jusqu'a k
## @param k la pronfondeur de la recherce (commence a 0)
## @param toutesLesSolutions si True alors cherche TOUTES les solutions, sinon s'arrete a la premiere (valeur oar defaut)
## @param initialise initialise les variables gloabl ITEARTION et SOLUTION, et le laebl des noeuds
## @ret instances contenant la solution OU echec si aucune solution trouvée
def forwardChecking(instances, k, touteLesSoltuions=None, initialise=None):
algo="ft"
global ITERATION
global SOLUTION
if touteLesSoltuions==None:
touteLesSoltuions=False
if initialise==None:
ITERATION=0
SOLUTION=[]
libPSC.NBCONTRAINTE=0
initLabelDesVarrables()
initialise=False
ITERATION=ITERATION+1
afficheNbIteration(algo,k)
print "....."
afficheSolution(algo,instances)
print "....."
 
return ECHEC
 
execfile("testConsistance.py")
##execfile("test.py")
View
220
■■■■■
 lab6/libPSC.py 0 → 100644
#################################################################################
print "Chargement du module variable et noeud pour PSC"
print "\t@version: 1.1 date: 24/04/2006 modified by the vincent.schickel-zuber@epfl.ch"
print "\t@author: vincent.schickel-zuber@epfl.ch date: 24/04/2006"
print "\t@copyright: EPFL-IC-IIF-LIA 2006"
#################################################################################
import copy
 
##contient le nombre de contraintes visitees
NBCONTRAINTE=0
 
##Classe modelisant une Variable
class Variable:
 
##Constructeur de la classe variable
##INITIALISE valeur = -1
##@param nom le nom de la variable; sert d'identifiant
##@param domaine le domaine de valeur sous fourme []
def __init__(self, nom, domaine):
self.nom=nom
self.domaine=domaine
self.valeur=-1
##met a jour la valeur
##@param valeur la nouvelle valeur
def metAJourValeur(self,valeur):
self.valeur=valeur
 
##Verifie que le nom est egalle a celui passe en parametre
##@param nom un nom a verifier
##@ret true <=>self.nom=nom
def nomEstEgalle(self,nom):
return self.nom==nom
## retourne la taille du domaine
def tailleDuDomaine(self):
return len(self.domaine)
## retourne true <=> le domaine est vide
def domaineEstVide(self):
self.tailleDuDomaine()==0;
 
##retourne une representation en String de la Variable
def __str__(self):
str = "var : < %s , %s >" %(self.nom, self.domaine)
return str
 
##class Contrainte:
class Contrainte:
 
##constructeur
##@param depart la variable de depart
##@param arrive la variable d'arrive
def __init__(self,depart,arrive):
self.depart=depart
self.arrive=arrive
 
##retournce la dimension
def dimension(self):
return 0
 
## verifie que la valeur de la variable 1 et 2 sont valide avec la contrainte
## @return true <=> valide
def estValide(self):
print "coucou"
 
##retourne une representation en String de la contrainte
def __str__(self):
str = "contrainte : < %s , %s >" %(self.depart.nom, self.arrive.nom)
return str
 
##Classe modelisant une contraite unaire
class ContrainteUnaire(Contrainte):
 
##constructeur
##@param ref valeur de reference
##@param op "<" || "<="
##@param refVar reference sur la variable
def __init__(self,refVar,op,ref):
Contrainte.__init__(self,refVar,refVar)
self.ref=ref
self.op=op
self.refVar=refVar
 
##retournce la dimension
def dimension(self):
return 1
 
## verifie que la valeur de la variable est valide avec la contrainte
## @param valeur la valeur a verifier
## @return true <=> valide
def estValide(self):
global NBCONTRAINTE
NBCONTRAINTE+=1
if (self.op=="<"):
return self.refVar.valeur<self.ref
elif (self.op=="<="):
return self.refVar.valeur<=self.ref
else:
print "|-| Operateur", self.op, "non implemente"
return false
##retourne une representation en String de la contrainte
def __str__(self):
str = "contrainte : < %s , %s , %s >" %(self.refVar.nom, self.op, self.ref)
return str
 
##Classe modelisant une contraite binaire
class ContrainteBinaire(Contrainte):
 
##constructeur
##@param op "<>" || "=="
##@param refVar1 reference sur la variable 1
##@param refVar2 reference sur la variable 2
def __init__(self,refVar1,op,refVar2):
Contrainte.__init__(self,refVar1,refVar2)
self.refVar1=refVar1
self.op=op
self.refVar2=refVar2
 
##retournce la dimension
def dimension(self):
return 2
 
## verifie que la valeur de la variable 1 et 2 sont valide avec la contrainte
## @return true <=> valide
def estValide(self):
global NBCONTRAINTE
NBCONTRAINTE+=1
if (self.op=="<>"):
return self.refVar1.valeur<>self.refVar2.valeur
elif (self.op=="=="):
return self.refVar1.valeur==self.refVar2.valeur
else:
print "|-| Operateur", self.op, "non implemente"
return false
 
## verifie que si la valeur de la variable 1 , alors la contrainte n'es pas violee
## @return true <=> possible
def estPossible(self):
global NBCONTRAINTE
uneVraie = lambda x, y : x or y
results=[]
if len(self.refVar2.domaine)==0 :
return False
for d in self.refVar2.domaine:
NBCONTRAINTE+=1
self.refVar2.metAJourValeur(d)
if (self.op=="<>"):
results.append(self.refVar1.valeur<>self.refVar2.valeur)
elif (self.op=="=="):
results.append(self.refVar1.valeur==self.refVar2.valeur)
else:
print "|-| Operateur", self.op, "non implemente"
results.append(false)
return reduce(uneVraie,results)
 
## verifie que si la valeur de la variable 1 , alors la contrainte n'es pas violee
## @return true <=> possible
def estPossibleAvecLabel(self):
global NBCONTRAINTE
uneVraie = lambda x, y : x or y
results=[]
if len(self.refVar2.label)==0:
return False
for d in self.refVar2.label:
NBCONTRAINTE+=1
self.refVar2.metAJourValeur(d)
if (self.op=="<>"):
results.append(self.refVar1.valeur<>self.refVar2.valeur)
elif (self.op=="=="):
results.append(self.refVar1.valeur==self.refVar2.valeur)
else:
print "|-| Operateur", self.op, "non implemente"
results.append(false)
return reduce(uneVraie,results)
 
##retourne une representation en String de la contrainte
def __str__(self):
str = "contrainte : < %s , %s , %s >" %(self.refVar1.nom, self.op, self.refVar2.nom)
return str
 
##Classe modelisant un Noeud
class Noeud:
 
##constructeur
##l'attribut pos est initialise a 0
##@param variable la variable referencee
def __init__(self,variable):
self.refVar=variable
 
 
##fait la consitance du noeud
##@param contraintes la liste de contraintes unaires pour ce noeud
def consitanceDuNoeud(self,contraintes):
... A IMPLEMENTER
 
##retourne une representation en String de la Variable
def __str__(self):
str = "Noeud -> %s " %(self.refVar)
return str
 
##classe modelisant un arc
class Arc:
 
##constructeur
##@param contrainte la contrainte referencee
def __init__(self,contrainte):
self.refContrainte=contrainte
 
##revise la consistance des valeurs de domaine piur la contrainte representee par cet arc
def reviser(self):
... A IMPLEMENTER
##retourne une representation en String de l'arc
def __str__(self):
str = "Arc -> %s " %(self.refContrainte)
return str
View
lab6/test.py 0 → 100644
View
lab6/testConsistance.py 0 → 100644