;version de coherence sans les NArcs;
					
			; -----------------------------------------;		 
				 ; Paquet de rgles ;
			;  pour la conversion des faits generes par;
                      	      ;le pilote pour le systeme expert ;
			; -----------------------------------------;

# Coherence   ;pour tester les paquets de regles;

$ RTest
SI
  Vrai(CoherenceTransformation)
ALORS
  PDebutEnsemble()
  PNumEtatQuestion(111)
  PFinEnsemble()
  Oublie()

;Regle de conversion en matrice pre;

$ RTransPre
SI
 (Existe  :a) (Existe :p) (Existe :t)
 (Existe  :v)
 RE(Arc  :a   arc)
 RE(ValArc  :a   :v)
 RE(PlaceTransition  :p  place)
 RE(PlaceTransition  :t  transition)
 RE(DebArc  :a   :p) RE(FinArc  :a   :t)  
 Vrai(CoherenceTransformation)

Alors

 MA(Pre :p  :t  :v)
 Oublie()
 
;Regle de conversion en matrice post;

$ RTransPost
SI
 (Existe  :a) (Existe :p) (Existe :t)
 (Existe :v)
 RE(Arc  :a   arc)
 RE(ValArc  :a   :v)
 RE(PlaceTransition  :p  place)
 RE(PlaceTransition  :t  transition)
 RE(DebArc  :a   :t) RE(FinArc  :a   :p)  
 Vrai(CoherenceTransformation)

Alors
 MA(Post :p  :t  :v)
 Oublie()
 
$ RImprimeReseau
SI
 Vrai(CoherenceTransformation)
ALORS
 EstVrai(CoherentTest)
 EstFaux(CoherenceTransformation)
 Oublie() 
 
 
;--------------------------------;
; Regles de coherence multigraphe;           
;--------------------------------;
= EstVrai(Coherent)

$ RMultiGraphe
  SI
  
  Vrai(CoherentTest)
  RE(Arc  :a1 arc)  RE(Arc :a2 arc)
  non Egal(:a1 :a2)
  RE(DebArc  :a1    :d1)
  RE(DebArc  :a2    :d2)
  Egal(:d1  :d2)
  RE(FinArc  :a1    :f1)
  RE(FinArc  :a2    :f2)
  Egal(:f1 :f2)
  
  ALORS
   EstFaux(coherent)
   PDebutEnsemble()
   PReponseObjet( :a1) 
   PReponseObjet( :a2)
   PErreur(:a1 5)
   PErreur(:a2 5)
   PFinEnsemble() 
   Oublie()
;----------------------------------------------;
;Deux places ne peuvent etre reliees par un arc;           
;----------------------------------------------;


 $ RTestLienPlace
SI
 Vrai(CoherentTest)
 RE(Arc  :a   arc)
 RE(DebArc  :a   :p) RE(FinArc  :a   :q)  
 RE(PlaceTransition :p  place)
 RE(PlaceTransition :q  place)
 
 ALORS
 PDebutEnsemble()
 PReponseObjet( :p)  
 PReponseObjet( :q) 
 PReponseObjet( :a)
 PErreur(:a 1)
 PFinEnsemble()
 EstFaux(Coherent)
 Oublie( ) 
 
;---------------------------------------------------;
;Deux transitions ne peuvent etre reliees par un arc;           
;---------------------------------------------------;
 
$ RTestLienTransition
SI
 Vrai(CoherentTest)
 RE(Arc  :a   arc)
 RE(DebArc  :a   :p) RE(FinArc  :a   :q)  
 RE(PlaceTransition :p  transition)
 RE(PlaceTransition :q  transition)
 
 Alors
 
 PDebutEnsemble()
 PReponseObjet( :p)   
 PReponseObjet( :q) 
 PReponseObjet( :a)
 PErreur(:a 2)
 PFinEnsemble()
 EstFaux(Coherent)
 Oublie( )
 
;------------------------------;
;Le marquage est positif ou nul;           
;------------------------------;
 
$ RMarkingNegatif
SI
(Existe :p) (Existe :m)
 RE(PlaceTransition :p  place)
 Vrai(MarkingTest)
 ME(Marking m0  :p   :m)
Inf(:m 0)
 Vrai(CoherentTest)
ALORS
 EstFaux(Coherent) 
 PDebutEnsemble()
 PReponseObjet(:p)
 PFinEnsemble()
 PErreur(:p 3)
 Oublie()
 
;--------------------------------------;
;La valuation est strictement positive ;           
;--------------------------------------;
 
$ RValuationNegative

SI
 (Existe :a) (Existe :v)
 RE(ValArc :a  :v)
 Vrai(CoherentTest)
 Inf(:v 1)
 
ALORS
 EstFaux(Coherent)
 PDebutEnsemble() 
 PReponseObjet(:a)
 PErreur(:a 4)
 PFinEnsemble()
 Oublie()
 
 $ RPlaceIsolee
 
 SI
 
  RE(PlaceTransition :p  place)
  non RE(Pre :p ) non RE(Post :p )
  Vrai(CoherentTest)
 
ALORS
 PDebutEnsemble()
 PReponseObjet (:p)
 PErreur( :p  6)
 PFinEnsemble()
 Oublie()

 $ RTransitionIsolee
 
 SI
  RE(PlaceTransition :t  transition)
  non RE(Pre  :t )  non RE(Post :t )
  Vrai(CoherentTest)
  
ALORS

 PDebutEnsemble()
 PReponseObjet (:t)
 PErreur( :t  7)
 PFinEnsemble()
 EstFaux(Coherent)
 Oublie()
 
$ RCalculMaxPlace
 SI
 (Existe ! :p) (Existe :v)
  RE(PlaceTransition  :p place)
  RE(RelNum  Objet :v)
  inf(:v :p)
 REPETE
  RD(RelNum Objet :v)
  RA(RelNum Objet :p)
  
$ RCalculMaxTrans
 SI
 (Existe ! :t) (Existe :v)
  RE(PlaceTransition  :t transition)
  RE(RelNum  Objet :v)
  inf(:v :t)
 REPETE
  RD(RelNum Objet :v)
  RA(RelNum Objet :t)
 
 $ RCalculMaxArc
 SI
 (Existe ! :a) (Existe :v) 
  RE(Arc :a arc)
  RE(RelNum  Objet :v)
  inf(:v :a)
 REPETE
  RD(RelNum Objet :v)
  RA(RelNum Objet :a)

;$RElimArcDebArcFinArc
 
 SiPasAutre
  Vrai(CoherenceTransformation)

ALORS
  RDO(Arc)
  RDO(DebArc)
  RDO(FinArc)
  RDO(ValArc);



= EstVrai(Interpreteur)
= PileCreer(PBut 100)
= PileCreer(PPaq 100)
= PileCreer(PPar 100)
= EstVrai(Descend)


