home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / spezial / 01 / newton / simple.pro < prev    next >
Encoding:
Prolog Source  |  1987-06-23  |  5.0 KB  |  126 lines
  1. /****************************************************************************/
  2. /*                             "VEREINFACHER"                               */
  3. /*                                                                          */
  4. /* PREDIKAT: vereinfache(term,term)                                         */
  5. /* VORAUSSETZUNGEN: DOMAIN term                                             */
  6. /* Vereinfacht terme in der Baumnotation                                    */
  7. /****************************************************************************/
  8. /*       STEHT AUS DEKLARATIONSGRUENDEN VOR DEM ABLEITER/INTEGRATOR         */
  9.  
  10.  
  11. predicates
  12.     vereinfache(term,term)
  13.     vereinfacheOperation(term,term)
  14.     separiereDualTerm(term,term,term)
  15.     konstruiereDualTerm(term,term,term,term)
  16.     atomarerTerm(term).
  17.     rotiereBaum(term,term)
  18.     sortiereArgs(term,term,term,term)
  19.     rotOp(term)    
  20.     eqOp(term,term)
  21.     istNConst(term)
  22.  
  23. /* Zusammenziehen von Termen */
  24. include "ZUZIEH.PRO"    
  25.  
  26. clauses        
  27.  
  28.     /* Terme vereinfachen */
  29.     vereinfache(A,A) :-
  30.       atomarerTerm(A) AND !.
  31.     vereinfache(A,AV) :-
  32.       vereinfacheOperation(A,AV), !.
  33.     vereinfache(A,AV) :- 
  34.       zusammenziehen(A,AZ), !, vereinfache(AZ,AV).
  35.     vereinfache(A,AV) :-
  36.       rotiereBaum(A,AR),
  37.       separiereDualTerm(AR,A1,A2),
  38.       vereinfache(A1,A1V), vereinfache(A2,A2V),
  39.       konstruiereDualTerm(A,A1V,A2V,NA),
  40.       vereinfacheOperation(NA,AV) AND !.
  41.     vereinfache(A,AV) :- 
  42.       rotiereBaum(A,AR),
  43.       separiereDualTerm(AR,A1,A2),
  44.       vereinfache(A1,A1V), vereinfache(A2,A2V),
  45.       konstruiereDualTerm(A,A1V,A2V,AV).
  46.     vereinfache(funk(Name,Arg),funk(Name,ArgV)) :-
  47.       vereinfache(Arg,ArgV), !.
  48.     vereinfache(npot(Basis,Exp),npot(BasisV,ExpV)) :-
  49.       vereinfache(Basis,BasisV), vereinfache(Exp,ExpV), !.
  50.  
  51.  
  52.     /* Operatoren, bei denen Baumrotationen sinnvoll sind */
  53.     rotOp(mal(_,_)). rotOp(plus(_,_)).
  54.  
  55.     /* "Rotieren" des  Baum */
  56.     rotiereBaum(A,A) :-
  57.       atomarerTerm(A), !.
  58.     rotiereBaum(funk(Name,Arg),funk(Name,ArgRot)) :-
  59.       rotiereBaum(Arg,ArgRot), !.
  60.     rotiereBaum(npot(Basis,Exp),npot(BasisRot,ExpRot)) :-
  61.       rotiereBaum(Basis,BasisRot), rotiereBaum(Exp,ExpRot), !.  
  62.     rotiereBaum(A,Arot) :-
  63.       rotOp(A), separiereDualTerm(A,A1,A2), eqOp(A,A1), 
  64.       sortiereArgs(A1,A2,NA1,NA2), konstruiereDualTerm(A,NA1,NA2,Arot) AND !.
  65.     rotiereBaum(A,Arot) :-
  66.       rotOp(A), separiereDualTerm(A,A1,A2), eqOp(A,A2), 
  67.       sortiereArgs(A1,A2,NA1,NA2) AND konstruiereDualTerm(A,NA1,NA2,Arot), !.  
  68.     rotiereBaum(A,Arot) :-
  69.       separiereDualTerm(A,A1,A2) AND ! 
  70.       AND rotiereBaum(A1,A1rot), rotiereBaum(A2,A2rot), 
  71.       konstruiereDualTerm(A,A1rot,A2rot,Arot). 
  72.   
  73.     sortiereArgs(nconst(X),Op,N1,N2) :-
  74.       separiereDualTerm(Op,A1,A2), atomarerTerm(A1), not(istNConst(A1)), 
  75.       konstruiereDualTerm(Op,nconst(X),A2,N2), !,
  76.       N1 = A1.
  77.     sortiereArgs(nconst(X),Op,N1,N2) :-
  78.       separiereDualTerm(Op,A1,A2), atomarerTerm(A2), not(istNConst(A2)),
  79.       konstruiereDualTerm(Op,nconst(X),A1,N2), !,
  80.       N1 = A2.
  81.     sortiereArgs(A,nconst(X),C,D) :- 
  82.        not(istNConst(A)), ! , sortiereArgs(nconst(X),A,C,D).
  83.     sortiereArgs(X,Op,X,Op) :-
  84.       separiereDualTerm(Op,nconst(_),nconst(_)).   
  85.  
  86.     /* Simple Vereinfachungen */
  87.     vereinfacheOperation(plus(nconst(A),nconst(B)),nconst(AB)) IF 
  88.       ! AND AB = A+B.
  89.     vereinfacheOperation(minus(nconst(A),nconst(B)),nconst(AB)) IF 
  90.       ! AND AB = A-B.
  91.     vereinfacheOperation(mal(nconst(A),nconst(B)),nconst(AB)) IF 
  92.       ! AND AB = A*B.
  93.     vereinfacheOperation(mal(nconst(0),_),nconst(0)) IF !. 
  94.     vereinfacheOperation(mal(_,nconst(0)),nconst(0)) IF !.
  95.     vereinfacheOperation(mal(nconst(1),A),A) IF !.
  96.     vereinfacheOperation(mal(A,nconst(1)),A) IF !.  
  97.     vereinfacheOperation(div(nconst(0),_),nconst(0)) IF !.
  98.     vereinfacheOperation(div(A,nconst(1)),A) IF !.
  99.     vereinfacheOperation(funk(exp,nconst(0)),nconst(1)) IF !.
  100.     vereinfacheOperation(npot(_,nconst(0)),nconst(1)) IF !.
  101.     vereinfacheOperation(npot(nconst(0),_),nconst(0)) IF !.
  102.     vereinfacheOperation(npot(nconst(1),_),nconst(1)) IF !.      
  103.     vereinfacheOperation(npot(nconst(A),nconst(B)),nconst(C)) IF
  104.         A > 0 AND ! AND D = ln(A), E = D*B, C=exp(E).
  105.  
  106.  
  107.     /* Argumente aus Funktor herausloesen */
  108.     separiereDualTerm(plus(A,B),A,B).  separiereDualTerm(minus(A,B),A,B).
  109.     separiereDualTerm(mal(A,B),A,B).   separiereDualTerm(div(A,B),A,B).
  110.     
  111.     /* Argumente in Funktor einfuegen */
  112.     konstruiereDualTerm(plus(_,_),A,B,plus(A,B)).  
  113.     konstruiereDualTerm(minus(_,_),A,B,minus(A,B)).
  114.     konstruiereDualTerm(mal(_,_),A,B,mal(A,B)).   
  115.     konstruiereDualTerm(div(_,_),A,B,div(A,B)).
  116.     
  117.     atomarerTerm(var(_)). atomarerTerm(const(_)).
  118.     atomarerTerm(nconst(_)).
  119.     
  120.     eqOp(plus(_,_),plus(_,_)).  eqOp(minus(_,_),minus(_,_)). 
  121.     eqOp(mal(_,_),mal(_,_)).    eqOp(minus(_,_),minus(_,_)).  
  122.     
  123.     istNConst(nconst(_)).
  124.  
  125.  
  126.