11. Rechnen mit den Grundfunktionen 12. Ein Beispiel: Die

11. Rechnen mit den Grundfunktionen
Maple kennt all die üblichen und viele nicht
so übliche Grundfunktionen. Auch die üblichen
Funktionalgleichungen, etwa die Additionstheoreme
der trigonometrischen Funktionen, sind Maple
bekannt. Verwendet wird hierzu der Befehl
expand(), den wir bisher nur zum Ausmultiplizieren
benutzt haben.
> sin(x+y);
sin(x + y )
> simplify(%);
sin(x + y )
> expand(%);
sin(x ) cos(y ) + cos(x ) sin(y )
> expand(exp(x+y));
ex ey
> expand(log(x*y));
ln(x y )
Dies wird nicht zu log(x)+log(y) expandiert, da
dies beispielsweise für x=y=-1 nicht möglich ist. Wir
müssen Maple sagen, dass wir uns x und y als
positive Zahlen denken.
> expand(log(x*y)) assuming x>0 and y>0;
ln(x ) + ln(y )
> expand(log(x*y)) assuming positive;
ln(x ) + ln(y )
Letzteres ist eine Kurzform um alle auftretenden
Variablen als positiv vorauszusetzen. Maple kennt auch
die Zusammenhänge zwischen den Grundfunktionen,
man muss aber manchmal auf passende Argumente
aufpassen.
> simplify(exp(log(x)));
x
> simplify(arcsin(sin(x))) assuming x>-Pi/2 and x<Pi/2;
x
Der Befehl combine() versucht Terme unter Verwendung
diverser Funktionalgleichungen zu verkürzen.
> combine(2*sin(x)*cos(x));
sin(2 x )
12. Ein Beispiel: Die Tschebyscheff
Polynome
Wir schauen uns einmal der Reihe nach die expandierte Form
von cos(nx) für n von 1 bis 10 an:
> n:=’n’:for n from 1 to 10 do cos(n*x)=expand(cos(n*x)); end;
cos(x ) = cos(x )
cos(2 x ) = 2 cos(x )2 − 1
cos(3 x ) = 4 cos(x )3 − 3 cos(x )
cos(4 x ) = 8 cos(x )4 − 8 cos(x )2 + 1
cos(5 x ) = 16 cos(x )5 − 20 cos(x )3 + 5 cos(x )
cos(6 x ) = 32 cos(x )6 − 48 cos(x )4 + 18 cos(x )2 − 1
cos(7 x ) = 64 cos(x )7 − 112 cos(x )5 + 56 cos(x )3 − 7 cos(x )
cos(8 x ) = 128 cos(x )8 − 256 cos(x )6 + 160 cos(x )4 − 32 cos(x )2 + 1
cos(9 x ) = 256 cos(x )9 − 576 cos(x )7 + 432 cos(x )5 − 120 cos(x )3 + 9 cos(x )
cos(10 x ) = 512 cos(x )10 − 1280 cos(x )8 + 1120 cos(x )6 − 400 cos(x )4 + 50 cos(x )2 − 1
Hier sehen wir ein Muster, für n von 1 bis 10 kann man cos(nx)
als Polynom von Grad n in cos(x) schreiben. Das Polynom von
Grad n mit cos(nx)=T_n(x) nennt man auch das n-te Tschebyscheff
Polynom. Um dieses mit Maple zu erhalten würden wir gerne
cos(x) oben durch x ersetzen. Dies kann man über den Befehl
subs(A=B, Term)
erreichen, dieser substituiert jedes Auftreten von A im Term
durch B. Man kann auch mehrere Substitutionen gleichzeitig
durchführen, diese werden dann in Klammern eingeschlossen.
Das ist eigentlich nicht nötig, aber systematischer:
subs({A1=B1,A2=B2,...}, Term)
Für die meisten Zwecke sind subs() und der früher eingeführte
eval() Befehl völlig gleichwertig, nur die Reihenfolge der beiden
Argumente ist genau anders herum. Gehen wir ans Werk:
> for n from 1 to 10 do T[n]:=subs(cos(x)=x,expand(cos(n*x)));
end;
T1 := x
T2 := 2 x 2 − 1
T3 := 4 x 3 − 3 x
T4 := 8 x 4 − 8 x 2 + 1
T5 := 16 x 5 − 20 x 3 + 5 x
T6 := 32 x 6 − 48 x 4 + 18 x 2 − 1
T7 := 64 x 7 − 112 x 5 + 56 x 3 − 7 x
T8 := 128 x 8 − 256 x 6 + 160 x 4 − 32 x 2 + 1
T9 := 256 x 9 − 576 x 7 + 432 x 5 − 120 x 3 + 9 x
T10 := 512 x 10 − 1280 x 8 + 1120 x 6 − 400 x 4 + 50 x 2 − 1
> eval(T[8],x=2);
18817
Diese indizierten Variablen erhält man durch
Variable[Index]
Das sollte man sparsam verwenden, die indizierten
Einträge sind keine eigenständigen Variablen sondern
weiterhin T, zum Beispiel
> T:=1;
T := 1
> eval(T[8],x=2);
18
13. Summen
Summen werden mit sum() dargestellt. Dabei sind sowohl
konkrete numerische Grenzen als auch symbolische Grenzen
erlaubt.
> n:=’n’:
> sum(k,k=1..50);
1275
> sum(k,k=1..n);
(n + 1 )2 n 1
− −
2
2 2
> simplify(%);
1 2 1
n + n
2
2
Der sum() Befehl ist für symbolische Rechnungen gedacht
und nicht zur Summation beliebiger Listen. Für letzteres gibt
es einen ähnlichen Befehl add() der nicht nur über "Zahlintervalle"
sondern auch über beliebige Listen von Zahlen summieren
kann, zum Beispiel
> EinigeZahlen:=[2,5,9,13,17,19,37,42,973];
EinigeZahlen := [2, 5, 9, 13, 17, 19, 37, 42, 973 ]
> add(k,k=EinigeZahlen);
1117
> add(1/k,k=EinigeZahlen);
7151905336
6802568955
Der Summationsbefehl sum() hat auch eine groß geschriebene
Variante Sum(...). Diese bezeichnet dieselbe Summe, aber Sum()
wird von Maple nicht sofort ausgewertet. Dies hat hauptsächlich
zwei Anwendungen:
1. Wie im folgenden Beispiel zum "Pretty-Printing" von Formeln.
2. Um eine eventuell zeitaufwendige symbolische Rechnung zu
vermeiden, wenn man die Summe sowieso zur numerischen
Auswertung an evalf() übergeben will.
Ist S eine groß geschriebene Summe, so kann Maple mit dem
Befehl value(S) zur Auswertung der Summe aufgefordert werden.
> S:=Sum(k,k=1..n):S=factor(value(S));
n
∑ k = n (n2+ 1 )
k=1
> for i from 1 to 6 do Sum(k^i,k=1..n)=factor(sum(k^i,k=1..n));
end;
n
∑ k = n (n2+ 1 )
k=1
n
∑k
2
=
k=1
n (n + 1 ) ( 2 n + 1 )
6
n
n 2 (n + 1 )2
k =
4
k=1
∑
3
n
n (n + 1 ) ( 2 n + 1 ) (3 n 2 + 3 n − 1 )
k =
30
k=1
∑
4
n
n 2 (2 n 2 + 2 n − 1 ) ( n + 1 )2
k =
12
k=1
∑
5
n
n (n + 1 ) ( 2 n + 1 ) ( 3 n 4 + 6 n 3 − 3 n + 1 )
k =
42
k=1
∑
6
Die ganz allgemeine Potenzsumme kann Maple aber nicht berechnen
> sum(k^a,k=1..n);
n
∑k
a
k=1
Reihen werden berechnet indem infinity (Unendlich) als
obere Grenze eingesetzt wird.
> sum(1/n^2,n=1..infinity);
π2
6
> sum(1/n,n=1..infinity);
∞
> sum((-1)^(n-1)/n,n=1..infinity);
ln(2 )
Wir wollen auch noch eine komplizierte Summe rechnen
> S:=Sum((4*n)!*(1+8*n)/(3^(2*n+1)*4^(4*n)*(n!)^4),n=0..infinity);
∞
S :=
∑
n=0
(4 n )! (1 + 8 n )
3
(2 n + 1 )
4
(4 n )
(n!)4
> S=value(S);
∞
 1
1
1 1 3 9  1
  , , , ,  , 1, 1 , 
hypergeom
=
(2 n + 1 ) (4 n )
 9
4 2 4 8  8
4
(n!)4 3
n=0 3
hypergeom(...) ist eine der in Maple eingebauten Grundfunktionen
eine sogenannte hypergeometrische Funktion. Wir wollen hier
nicht erklären was diese sind, es handelt sich um ein klassisches
∑
(4 n )! (1 + 8 n )
Thema zu dem es reichlich Literatur gibt.
Dieser konkrete hypergeometrischer Wert läßt sich tatsächlich
noch expliziter ausrechnen. Um auf die rechte Seite der obigen
Gleichung zuzugreifen verwendet man den Befehl rhs(), der
für "right hand side" steht, analog gibt es auch lhs(), also
rhs( X = Y ) Rechte Seite der Gleichung, also Y
lhs( X = Y )
Linke Seite der Gleichung, also X
> simplify(rhs(%));
 1
1
1 1 3 9  1
hypergeom  , , , ,  , 1, 1 , 
 9
3
4 2 4 8  8
Das hat nichts gebracht, schauen wir uns also einmal den
numerischen Wert an. Wir wollen mit 20 Stellen Genauigkeit
rechnen, und um nicht extra Digits zu setzen, benutzen wir
die alternative Form von evalf()
> evalf(S,20);
0.36755259694786136634
Nun schauen wir mit dem schon früher eingeführten
Befehl identify() was Maple mit dieser Zahl anfangen kann
> identify(%);
2 3
3π
> evalf(%%%,20);
0.36755259694786136633
Dies ist tatsächlich das korrekte Ergebnis, d.h. unsere Reihe
ist exakt 2/(sqrt(3)*Pi). Maple kann das leider nicht einsehen.
> simplify(value(S)-2/(sqrt(3)*Pi));
 1
1 1 3 9  1
hypergeom  , , , ,  , 1, 1 ,  π − 2 3
 9
1
4 2 4 8  8
π
3
Noch einmal das Endergebnis
> S=%%%;
∞
∑
(4 n )! (1 + 8 n )
(2 n + 1 )
3
Wir versuchen noch 1/n^3 zu summieren
> sum(1/n^3,n=1..infinity);
n=0
4
(4 n )
(n!)4
=
2 3
3π
ζ(3 )
Das täuscht die Lösung nur vor, es ist per Definition
> zeta(x)=Sum(1/n^x,n=1..infinity);
∞
ζ(x ) =
∑ n1
x
n=1
für x>1, die sogenannte Riemannsche Zeta-Funktion. Für
Maple ist die Zeta-Funktion eine der eingebauten Grundfunktionen
unter dem Namen Zeta(x). Wir verwenden den Plot Befehl um
uns den Funktionsgraphen der Zeta Funktion anzuschauen.
Dabei bleiben wir etwas von der 1 weg da die Zeta-Funktion
dort einen Pol hat.
> plot(Zeta(x),x=1.1..4,y=0..5);
5
4
3
y
2
1
0
1.5
2
2.5
x
14. Potenzreihen
Es können auch Reihen berechnet werden in denen noch
Parameter, also weitere freie Variablen, vorkommen, und
als ein Beispiel schauen wir uns ein paar Potenzreihen an.
> sum(x^k,k=0..infinity);
1
−
x−1
Wie Sie wissen gilt dies eigentlich nur für |x| < 1, solche
Konvergenzfragen werden von Maple ignoriert
> sum(k*x^k,k=0..infinity);
x
(x − 1 )
2
3
3.5
4
> sum(x^k/k!,k=1..infinity);
ex − 1
> sum(x^k/(2*k)!,k=0..infinity);
cosh( x )
15. Trigonometrische Reihen
Eine trigonometrische Reihe ist eine Reihe der Form
> T:=a[0]/2+Sum(a[n]*cos(n*x)+b[n]*sin(n*x),n=1..infinity);
 ∞

1

a
T := 0 + 
(an cos(n x ) + bn sin(n x ))


2
n = 1

Schauen wir uns einmal ein konkretes Beispiel an
> fN:=(4/Pi)*Sum(sin((2*n-1)*x)/(2*n-1),n=1..N);
 N sin((2 n − 1 ) x ) 

4 


2n−1
n = 1

fN :=
π
und betrachten einige Partialsummen dieser Reihe
> plot(eval(fN,N=5),x=-2*Pi..2*Pi);
∑
∑
1
0.5
–6
–4
–2
2
4
x
–0.5
–1
> plot(eval(fN,N=10),x=-2*Pi..2*Pi);
6
1
0.5
–6
–4
–2
0
2
4
x
–0.5
–1
> plot(eval(fN,N=20),x=-2*Pi..2*Pi);
6
1
0.5
–6
–4
0
–2
2
4
x
–0.5
–1
Die Reihe konvergiert gegen eine sogenannte Rechteckwelle
und wir wollen einmal schauen ob Maple diese berechnen kann.
> eval(fN,N=infinity);
 ∞ sin((2 n − 1 ) x ) 

4 


2
n
−
1
n = 1

π
> value(%);
  1 + e (x I) 
 1 + e (x I) 


 

 + ln
 I
 −ln −
(
x
I
)
(
x
I
)


 

  −1 + e 
 −1 + e  
π
> evalc(%);


sin(x ) (−1 + cos(x ))
(1 + cos(x )) sin(x )
−  −arctan −
,
+

 (−1 + cos(x ))2 + sin(x )2 (−1 + cos(x ))2 + sin(x )2
∑
6
sin(x )2


 + arctan


2
2

(−1 + cos(x ))2 + sin(x )2 
(−1 + cos(x )) + sin(x )
sin(x ) (−1 + cos(x ))
(−1 − cos(x )) sin(x )
+
2
2
2
2,
(−1 + cos(x )) + sin(x )
(−1 + cos(x )) + sin(x )



 1 
(1 + cos(x )) (−1 + cos(x ))
sin(x )2



/ π +  − ln
2
2 +
2
2 
 2 


(−1 + cos(x )) + sin(x )
(−1 + cos(x )) + sin(x )
(−1 − cos(x )) (−1 + cos(x ))
−

 (−1 − cos(x )) (−1 + cos(x ))
sin(x )2


−

2
2
2
2
 (−1 + cos(x )) + sin(x )
(−1 + cos(x )) + sin(x ) 
2

sin(x ) (−1 + cos(x ))
(−1 − cos(x )) sin(x ) 

+  −
−
2
2
2
2
 (−1 + cos(x )) + sin(x )
(−1 + cos(x )) + sin(x ) 

 (1 + cos(x )) (−1 + cos(x ))
sin(x )2


+

2
2
2
2
 (−1 + cos(x )) + sin(x )
(−1 + cos(x )) + sin(x ) 

 1 
 + ln
 2 
2
2
2 
 sin(x ) (−1 + cos(x ))
(1 + cos(x )) sin(x )   
  I / π
+ 
2
2 −
2
2  
 (−1 + cos(x )) + sin(x )
(−1 + cos(x )) + sin(x )   
> simplify(%);


sin(x )
 sin(x )

, 0 
arctan −
, 0  − arctan
 −1 + cos(x ) 
 −1 + cos(x ) 
π
Man sieht es dieser Formel zwar nicht direkt, aber
dies ist tatsächlich das korrekte Ergebnis, wie uns
beispielsweise ein Funktionsplot zeigt.
> plot(%,x=-2*Pi..2*Pi);
1
0.5
–6
–4
–2
2
4
6
x
–0.5
–1
Zum Abschluß dieses Beispiels wollen wir uns noch einen direkten
Vergleich dieser Grenzfunktion mit der Partialsumme etwa für N=5
anschauen. Hierzu wollen wir beide Funktionen in ein gemeinsames
Bild zeichnen. Auch dies kann der Plot-Befehl leisten, man muss die
beiden Funktionen nur in eckigen Klammern [ ... ] als erstes Argument
des Plot-Befehls verwenden.
> plot([%%,eval(fN,N=5)],x=-2*Pi..2*Pi,discont=true,color=[blue,re
d]);
1
0.5
–6
–4
–2
2
4
x
–0.5
–1
Die letzte Option ’color=[...]’ ist dabei optional, sie kann dazu
verwendet werden die Farben der einzelnen Graphen festzulegen.
16. Ein trigonometrisches Beispiel
Wir wollen die folgende trigonometrische Summe in einer
möglichst übersichtlichen geschlossenen Form auswerten.
> S:=Sum(cos(omega*t-alpha-n*beta),n=-N..N);
N
S :=
∑ cos(−ω t + α + n β)
n = −N
> value(S);
1
− (cos(ω t ) cos(α ) cos(β ) + sin(ω t ) sin(α ) cos(β ) − cos(ω t ) cos(α ) − sin(ω t ) sin(α )
2
1
+ cos(ω t ) sin(α ) sin(β ) − sin(ω t ) cos(α ) sin(β )) cos((N + 1 ) β ) / (cos(β ) − 1 ) + (
2
6
cos(ω t ) cos(α ) cos(β ) + sin(ω t ) sin(α ) cos(β ) + cos(ω t ) sin(α ) sin(β ) − sin(ω t ) cos(α ) sin(β )
1
+ cos(ω t ) cos(α ) + sin(ω t ) sin(α )) sin((N + 1 ) β ) / sin(β ) + (cos(ω t ) cos(α ) cos(β )
2
+ sin(ω t ) sin(α ) cos(β ) − cos(ω t ) cos(α ) − sin(ω t ) sin(α ) + cos(ω t ) sin(α ) sin(β )
1
− sin(ω t ) cos(α ) sin(β )) cos(N β ) / (cos(β ) − 1 ) + (cos(ω t ) cos(α ) cos(β )
2
+ sin(ω t ) sin(α ) cos(β ) + cos(ω t ) sin(α ) sin(β ) − sin(ω t ) cos(α ) sin(β ) + cos(ω t ) cos(α )
+ sin(ω t ) sin(α )) sin(N β ) / sin(β )
Das ist bereits ein Fortschritt, die Formel ist zwar noch
unbrauchbar groß, es kommt aber keine Summe mehr vor.
Wir lassen Maple ein wenig weiter machen.
> simplify(%);
1
(cos(ω t ) cos(α ) cos(β ) sin(N β ) + cos(β ) sin((N + 1 ) β ) sin(ω t ) sin(α )
2
+ sin(ω t ) sin(α ) cos(β ) sin(N β ) + cos(β ) sin((N + 1 ) β ) cos(ω t ) cos(α )
− cos(β ) cos((N + 1 ) β ) sin(ω t ) cos(α ) − cos(β ) cos(N β ) cos(ω t ) sin(α )
+ cos(β ) cos((N + 1 ) β ) cos(ω t ) sin(α ) + cos(β ) cos(N β ) sin(ω t ) cos(α )
− cos((N + 1 ) β ) sin(β ) cos(ω t ) cos(α ) − sin(N β ) sin(ω t ) cos(α ) sin(β )
+ cos(N β ) sin(β ) cos(ω t ) cos(α ) + sin((N + 1 ) β ) cos(ω t ) sin(α ) sin(β )
− sin((N + 1 ) β ) sin(ω t ) cos(α ) sin(β ) + cos(N β ) sin(β ) sin(ω t ) sin(α )
+ sin(N β ) cos(ω t ) sin(α ) sin(β ) − cos((N + 1 ) β ) sin(β ) sin(ω t ) sin(α )
+ sin(N β ) cos(ω t ) cos(α ) + sin((N + 1 ) β ) sin(ω t ) sin(α ) + sin(N β ) sin(ω t ) sin(α )
+ sin((N + 1 ) β ) cos(ω t ) cos(α ) − cos((N + 1 ) β ) sin(ω t ) cos(α ) − cos(N β ) cos(ω t ) sin(α )
+ cos((N + 1 ) β ) cos(ω t ) sin(α ) + cos(N β ) sin(ω t ) cos(α )) / sin(β )
Durch Anwendung trigonometrischer Formeln über combine()
kann man den Ausdruck weiter verkleinern
> combine(%);
1 sin(ω t − α + N β + β ) + sin(−ω t + α + N β + β ) + sin(ω t − α + N β ) + sin(−ω t + α + N β )
2
sin(β )
Das ist schon nicht schlecht. Die Parameter omega, t und
alpha kommen nur noch als omega*t-alpha vor, und das
soll auch so bleiben. Wenn wir aber den Zähler expanden,
so werden die drei wieder auseinander gerissen. Wir
vermeiden dies, indem wir sie als zeta zusammenfassen.
Das hätte man auch ganz zu Anfang tun können.
Das wir am Ende das zeta dann wieder zurück substituieren
müssen, merken wir uns die ganze Substitution in einer
Variablen zetasubs.
> zetasubs:=zeta=omega*t-alpha;
zetasubs := ζ = ω t − α
Es tritt noch ein weiteres kleine Problem auf. Der Befehl subs()
macht rein syntaktische Ersetzungen er merkt aber nicht das
-omega*t+alpha als -zeta substituiert werden kann. Es gibt einen
etwas intelligenteren Substitutionsbefehl algsubs(), der auch
solche Folgerungen aus einer Substitution berücksichtigt:
algsubs(A=B, Term)
> algsubs(rhs(zetasubs)=zeta,%%);
1 sin(ζ + N β + β ) + sin(−ζ + N β + β ) + sin(ζ + N β ) + sin(−ζ + N β )
2
sin(β )
> expand(%);
cos(ζ) cos(β ) sin(N β )
cos(ζ) sin(N β )
+ cos(ζ) cos(N β ) +
sin(β )
sin(β )
> simplify(%);
cos(ζ) (cos(β ) sin(N β ) + cos(N β ) sin(β ) + sin(N β ))
sin(β )
Jetzt ist cos(zeta) schön abgespalten, und wir wollen jetzt
die Klammer im Zähler vereinfachen. Direkt combine()
anzuwenden funktioniert aber nicht, da das ’cos(zeta)’ dann
wieder in die Terme hineingemischt wird. Wir wollen
combine() nicht auf den gesamten Term, sondern nur auf
die Klammer anwenden. Hierfür gibt es verschiedene
Möglichkeiten.
Wir könnten wieder mit Substitutionen herumtricksen, etwa
cos(zeta)=A und sin(beta)=B substituieren, dann combine()
machen und alles zurücksubstituieren. Hier wollen wir einen
alternativen Weg vorstellen und schauen uns erst einmal an
was Maple von unserem Term überhaupt weiss
> whattype(%);
*
> op(%%);
cos(ζ), cos(β ) sin(N β ) + cos(N β ) sin(β ) + sin(N β ),
Für Maple liegt also ein Produkt vor (Typ *) und der Befehl
op() hat die drei Operanden dieses Produkts geliefert. Der
Maple Befehl:
map(Kommando, Formel)
wendet einen Maple Befehl ’Kommando’ auf alle Teilformeln
von Formel an, aber nicht auf die Formel selbst. Was Maple
jeweils für die Teilformeln hält, kann man sich mit dem obigen
op() Befehl anschauen. Hier wenden wir combine() auf jede
der drei Teilformeln an. Effektiv wirkt combine() dann nur
auf die Klammer im Zähler, da es bei den anderen beiden
Teilformeln nichts zu combinen gibt.
> map(combine,%%%);
cos(ζ) (sin(N β + β ) + sin(N β ))
sin(β )
> T:=%;
cos(ζ) (sin(N β + β ) + sin(N β ))
T :=
sin(β )
1
sin(β )
Sehr schön, es geht aber noch besser. Maple kommt von
alleine nicht weiter, wir müssen schon selbst etwas Hand
anlegen. Der Befehl trigsubs(...) schlägt eine Liste von
möglichen trigonometrischen Umformungen eines Terms
vor. Uns interessiert die Klammer im Zähler, an die wir
wieder mit dem Befehl op() herankommen.
> op(T);
cos(ζ), sin(N β + β ) + sin(N β ),
1
sin(β )
> trigsubs(%[2]);

1   β 

 2 sin N β + β  cos  

2   2 

Ob wir mit der vorgeschlagenen Substitution etwas
anfangen können, bleibt uns überlassen. In diesem Beispiel
führen wir die Substitution durch um die Summe durch
ein Produkt zu ersetzen.
> subs(%%[2]=%[1],T);
1  β 

2 cos(ζ) sin N β + β  cos 
2  2 

sin(β )
Schauen wir uns auch noch an wie wir den Nenner
umschreiben können. Zähler und Nenner eines Bruchs
erhielt man über die beiden Befehle
denom(X/Y) Nenner, also Y
numer(X/Y) Zähler, also X
> trigsubs(denom(%));


β 
 


tan
2






β

β
1
1
2
-1

(
β
I
)
(
−I
β
)


,−
,
,

I
(
e
−
)
 sin(β ), −sin(−β ), 2 sin  cos ,
e
2


 2   2  csc(β ) csc(−β )
2

β






1 + tan 

2 

Hier haben wir gleich eine ganze Liste von Möglichkeiten.
Wir entscheiden uns für die dritte in dieser Liste, da sich
dann das cos(beta/2) wegkürzt.
> subs(denom(%%)=%[3],%%);
1 

cos(ζ) sin N β + β 
2 

β 
sin 
2 
Das ist unser Endergebnis. Wir müssen nur noch daran
denken zeta zurück zu substituieren.
> R:=subs(zetasubs,%);
1 

cos(ω t − α ) sin N β + β 
2 

R :=
β 
sin 
2 
> S=R;
1 

cos(ω t − α ) sin N β + β 
2 

cos(−ω t + α + n β ) =
β 
n = −N
sin 
2 
N
∑
17. Grenzwerte
Grenzwerte können mit dem Maple Befehl
limit(Formel, x=a)
berechnet werden wobei der Grenzwert in a gebildet werden
soll. Dabei ist a=infinity für Grenzwerte in unendlich erlaubt.
Dieser Befehl wird sowohl für Grenzwerte von Folgen als auch
für Grenzwerte von Funktionen verwendet.
> limit(exp(-x),x=infinity);
0
Wie bei sum() gibt es auch eine großgeschriebene Variante
Limit() die zum "Pretty-Printing" verwendet werden kann
> A:=Limit(arctan(x),x=infinity):
> A=value(A);
π
lim arctan(x ) =
2
x →∞
Der limit() Befehl ist nicht perfekt, selbst einige eigentlich recht
einfache Grenzwerte schafft Maple nicht direkt.
> A:=(3*n^3-7*n^2+5*n+sin(n^2+3))/(5*n^3+2*n^2-43*n+(-1)^n*cos(sqr
t(n)));
A :=
3 n 3 − 7 n 2 + 5 n + sin(n 2 + 3 )
3
2
n
5 n + 2 n − 43 n + (-1) cos( n )
> limit(A,n=infinity);
undefined
In einigen Fällen hilft es dann Maple über geeignete ’assuming’
Zusätze Nebenbedingungen mitzuteilen, beispielsweise nicht
> Limit(exp(-a*x)*cos(b*x),x=infinity):%=value(%);
lim e
( −a x )
cos(b x ) = lim e
x →∞
( −a x )
x →∞
sondern
> %%=value(%%) assuming a>0;
lim e
( −a x )
cos(b x ) = 0
x →∞
Liegt dagegen nur ein links- oder rechtsseitiger Grenzwert
vor so muss dies Maple auf eine etwas andere Art
mitgeteilt werden.
> f:=cos(x)^(1/x^3);
f := cos(x )
> Limit(f,x=0):%=value(%);
 1 
 
 3 
x 
cos(b x )
lim cos(x )
 1 
 
 3 
x 
= undefined
x →0
hat keinen Grenzwert, es gibt aber einen
rechtsseitigen Grenzwert
> Limit(f,x=0,right):%=value(%);
lim cos(x )
x → 0+
>
 1 
 
 3 
x 
=0