12) Kommentar zum Programm "abstrderiv8" und zu den Unterprogrammen,             [13.txt]
          select, has, typematch, lhs, rhs
      =====================================================================
      > restart:
      > with(share):
      > with(FPS):
      Struktur des Programms "abstrderiv8"
      ===============================
      > read( abstrderiv8);
      Wende "FPS" auf die gegebene Funktion an.
      1)Teste, ob das Ergebnis aus  2 Termen besteht: Wenn
                        1.1) beide Terme durch ein "+" oder "-"verbunden sind , wende das Programm
                             "aderivsum3" auf das Ergebnis an. Wenn sie
                        1.2) durch ein "*" verbunden sind, wende "aderivPROD4" an.
                        1.3) Ein Ergebnis wie bei "FPS(exp(x),x=0)" hat aber ebenfalls 2 Terme,
                             wovon der erste "Sum" ist, d.h. ein Ausdruck, dessen Datenstruktur
                             den "Header" oder nullten Operanden "Sum" hat, dann wende das Programm
                             "AderivSUM5" an.
      2) Wenn das Ergebnis ein Produkt ist und 3 Terme hat, wende "aderivPROD4" an.
      3) Anderenfalls beende das Programm mit einer Fehlermeldung.

      Zu 1.1):
      > FPS(cos(x),x=a);whattype(%);
      Zu 1.2):
      > FPS(exp(x),x=a);whattype(%);nops(%%);
      Zu 1.3):
      > FPS(exp(x),x=0);nops(%);op(%%);op(0,%%%);
      Zu 2):
      > f:=x->(1+x)^(1/2);FPS(f(x),x=a);whattype(%);nops(%%);
      Das Programm "aderivSUM5" ist fuer ganz einfache Faelle wie FPS(exp(x),x=0) zustaendig. Es
      wird vom Hauptprogramm mit den Argumenten aderivSUM5(t1,x,a) aufgerufen, wobei
      t1=FPS(f(x),x=a) ist. Also ist hier args[1] =FPS(f(x),x=a) und damit F=FPS(f(x),x=a).
      Zunaechst wird geprueft, dass F eine Datenstruktur vom Typ "Sum" ist und ob in op([2,2],F)
      der Ausdruck infinity; vorkommt:
      > read( aderivSUM5);
      Beispiel: F:=FPS(exp(x),x=0);
      > F:=FPS(exp(x),x=0);
      > aderivSUM5(FPS(exp(x),x=0),x,0);
      > op([2,2],F);has(op([2,2],F),infinity);op(2,F);
      Wenn das richtig ist, muss op([2,1],F); die lokale Variable k sein:
      > op([2,1],F);
      Nun wird mit dem Befehl
      > typematch(op(select(has,{op(op(1,F))},x)),(a::anything)^(b::anything),'s');
      > s;
      > s[2];op(2,s[2]);
      verifiziert, ob die Terme in op(op(1,F), die x enthalten, von der Form
      (irgendetwas)^(irgendetwas) sind, um sicherzugehen, dass op(1,F) eine x-Potenz enthaelt
      > {op(op(1,F))};
      > op(select(has,{op(op(1,F))},x));
      und dann mittels (hier ist a=0)
      > a:=0:has(op(1,F)/((x-a)^op(2,s[2])),x);a:='a':
      geprueft, ob nach Dividieren von op(1,F) durch (x-a)^k kein "x" mehr vorkommt. Kommt
      noch eins vor, so endet das Programm mit einer Fehlermeldung.
      Die zweite Abfrage ist fuer die Faelle gedacht, wo op(1,F)=x^k ist, wie etwa bei der
      geometrischen Reihe:
      > F:=FPS(1/(1-x),x=0);op(1,F);
      Dann ist
      > typematch(op(1,F),a::anything^b::anything,'s');
      > s;
      waehrend die vorherige Abfrage
      > typematch(op(select(has,{op(op(1,F))},x)),(a::anything)^(b::anything),'s1');
      zu einem falschen Ergebnis fuehrt:

      > s1;
      Und mit den vorher geladenen Daten
      > Koeff := `derivative of order`:a:=0:
      wuerde der erste Auswertungsbefehl
      > Koeff(op(2,s1[2])) = expand(op(1,F)/((x-a)^op(2,s[2]))*op(2,s[2])!);
      nicht funktionieren, waehrend der zweite das richtige Ergebnis liefert:
      > typematch(op(1,F),a::anything^b::anything,'s');s;
      > expand(op(1,F)/((x-a)^op(2,s[2]))*op(2,s[2])!);
      Die anderen Unterprogramme haben folgende Aufgaben:
      "aderivsum3" steuert in Faellen wie
      > FPS(sin(x),x=a);
      wo eine Summe aus zwei Produkten entsteht, das Zusammensetzen der Ergebnisse von
      "aderivPROD4".
      "aderivPROD4" behandelt Produkte, die einen konstanten Faktor und eine Summe
      enthalten, wie
      > FPS(exp(x),x=a);
      >