13) n-te Ableitung fuer symbolisches n, hackware-Package, addressof, pointto       [14.txt]
      ==============================================================================
      > restart:with(share):with(FPS):
      > read( aderivsum3):read( aderivSUM5):read( aderivPROD4):
      > read( abstrderiv8):
      > abstrderiv8(exp,0);
      > abstrderiv8(exp,a);
      > abstrderiv8(ln,1);
      > t1:=FPS(ln(x),x=1);
      > abstrderiv8(ln,a);
      > t1:=FPS(ln(x),x=a);
      > f:=x->1/(1-x);abstrderiv8(f,0);
      > f:=x->1/(1+x);abstrderiv8(f,0);
      > f:=x->ln(1+x);abstrderiv8(f,0);
      > abstrderiv8(sin,0);
      Die Ergebnisse sind gegebenenfalls zu ergaenzen durch:
      Fuer fehlende Werte von k ist die Ableitung =Null.
      > abstrderiv8(cos,0);
      > abstrderiv8(cos,a);
      > abstrderiv8(sin,a);
      > FPS(sin(x),x=a);
      > FPS(cos(x),x=a);
      > f:=x->ln((1+x)/(1-x));
      > abstrderiv8(f,0);
      > FPS(arctan(x),x=0);
      > abstrderiv8(arctan,0);
      > f:=x->(1+x)^alpha;
      > abstrderiv8(f,0);
      > ?Pochhammer
      > ?pochhammer
      The pochhammer symbol is defined for positive integer n and real x as

                       pochhammer(x,n) = x*(x+1)*...*(x+n-1)

      > f:=x->(1+x)^(1/2);
      > abstrderiv8(f,0);
      > FPS(f(x),x=0);
      > abstrderiv8(tan,0);
      > abstrderiv8(tan,Pi/2);
      =============================================================================
      Versuch einer Probe:
      > f:=x->sin(x^2);
      > FPS(f(x),x=0);
      > abstrderiv8(f,0);
      Zur x-Potenz mit Exponent 4*k+2 gehoert in der Taylorformel der Nenner (4*k+2)!, also sollte
      die (4*k+2)-te Ableitung den folgenden Wert haben:
      > simplify((4*k+2)!/(2*k+1)!);
      > ?GAMMA
      Fuer natuerliches n gilt GAMMA(n) = (n-1)!; und 0!=1 .
      > test1:=simplify(abstrderiv8(f,0));
      > op(rhs(test1));
      Finde die interne Adresse der lokalen Variable k:
      > addressof(op([2,2],rhs(test1)));
      (Das Ergebnis wird bei jedem Neudurchlauf anders lauten.)
      > assume(k,posint); about(k);
      Es ist zwar moeglich, das lokale k mittels seiner Adresse anzusprechen mittels "pointto",
      aber es ist nicht moeglich, dem lokalen k eine Eigenschaft zuzuweisen:
      > pointto(%);
      > assume(pointto(%%),posint); about(pointto(%%%));
      Der Folgende Ausdruck sollte =0 sein:
      > 1/4*2^(4*k+4)*GAMMA(2*k+3/2)/(sqrt(Pi))-(-1)^pointto(addressof(op([2,2],rhs(test1))))*rhs(test1);
      > simplify(%,assume=posint);
      Nur das globale k hat eine Tilde "~". Maple vereinfacht den Ausdruck nicht, weil die zweite
      Potenz "16^(k+1)" einen negativen Exponenten haben koennte und damit komplex waere. Es ist
      aber offensichtlich, dass dieser Ausdruck verschwindet.
      ===================================================================================
      Weitere Beispiele:
      Fur das obige f:
      > abstrderiv8(f,a);
      > f:=x->cos(x^2);
      > abstrderiv8(f,0);
      > abstrderiv8(f,a);
      > abstrderiv8(sin,0);
      Noch ein Schoenheitsfehler unseres Programms: Der Entwicklungspunkt darf nicht "x" genannt
      werden:
      > abstrderiv8(sin,x);
      > abstrderiv8(sin,a);
      =================================================================================
      Ein Beispiel, das von unserem Programm nicht bewaeltigt wird:
      > f:=(x)->sin(x)^4;
      > abstrderiv8(f,a);
      > FPS(f(x),x=a);
      ================================================================================
      Dasselbe fuer a=0:
      > abstrderiv8(f,0);
      Kontrolle: Es sollte gelten: Wert der rechten Seite fuer k=2,3,4 ist gleich diff(f(x),x$2),
      diff(f(x),x$3), diff(f(x),x$4) an der Stelle x=0:
      test2:=rhs(%);

      > test2:=rhs(%);
      > op([1,2,2],test2);
      > addressof(%);
      > K:=pointto(%);
      > subs(K=2, test2)-subs(x=0,diff(f(x),x$2));
      > simplify(%,trig);
      > subs(K=3, test2)-subs(x=0,diff(f(x),x$3));
      > simplify(%,trig);
      > subs(K=4, test2)-subs(x=0,diff(f(x),x$4));
      > simplify(%,trig);
      OK.
      > addressof(K);
      >