#                      MAPLE fuer ANALYSIS 
#                RWTH -Aachen, Wintersemester 1997/98
#                         E. Goerlich
#
# Maple -Input von Kapitel 8:

# Kapitel 8: Standard-Umformungen f"ur sin, cos, exp, log.
# =========================================
# a) Das Befehlspaar "expand", "combine".
# ----------------------------------------------------------------------
> ?combine
> test1 := expand(cos(4*x));
> combine(test1,trig);
> test2 := expand(cos(x+y));
> combine(test2,trig);
# Hier werden auch gr"ossere Summen bew"altigt:
> test3 := expand(cos(10*x) - 3*cos(6*x));
> combine(test3,trig);
# Eingebaute Sperre in "expand":
> expand(cos(100*x));
# "workaround":
> test4:= expand(cos((a+b+c)*x));
# Der Befehl "subs" bewirkt eine Substitution. Dabei
# ist auf die Reihenfolge zu achten: Wenn a durch 99 ersetzt werden
# soll, muss a=99 geschrieben werden, nicht 99=a und auch
# nicht a:=99. Man darf auch eine Menge von drei Ersetzungen eingeben:
> test4:= subs({a=99,b=99,c=2}, test4);
> test4:= expand(test4):
# Anzahl der Operanden:
> nops(");
# Der folgende Befehl braucht eine knappe Minute.
> combine(test4, trig);
# Bemerkung: Der Befehl combine( ,trig) kann 
# scheitern, wenn x ein rationales Vielfaches von Pi ist. Siehe 
# dazu das sp"atere Kapitel "uber "Die Behandlung gr"osserer 
# trigonometrischer Ausdr"ucke".
# ============================================
# Das Befehlspaar "expand" und "combine(  ,exp)".
> test5 := expand(exp(a+b+c));
> combine(test5,exp);
# ============================================
> test6 := expand(log(4*Pi^2*x^3));
# Hier ist es egal, ob wir "log" oder "ln" schreiben:
> test7 := expand(ln(4*Pi^2*x^3));
# Aber hier nicht:
> combine(test6,log);
> combine(test6,ln);
# ==========================================
# b) Die Befehlsfolge "convert( ,exp), expand, simplify"
# ----------------------------------------------------------------------
# 
> test3;
> convert(test3,exp);
> expand(");
> simplify(");
# ============================================
# Manche Umformungen werden beim Aufrufen der betreffenden Funktion
# sofort ausgef"uhrt:
> sin(1+Pi);                           
> cos(1+2*Pi);
# andere nicht:
> cos(n*2*Pi);
# ============================================
# c) Der Befehl "trigsubs".
# ----------------------------------------------------------------------
# Dieser Befehl nimmt eine Sonderstellung ein: Er liefert keinen 
# Ausdruck sondern eine Liste, er braucht vorweg den Befehl 
# "readlib(trigsubs)", und er akzeptiert nur Ausdr"ucke, die aus 
# zwei Termen bestehen.
> trigsubs(test1);
> readlib(trigsubs):
> trigsubs(test1);
> test1;
> trigsubs(test2);
> test2;
> trigsubs(test3);
> test3;
> trigsubs(sin(a*x)-2*sin(b*x));
> trigsubs(sin(a*x) * sin(b*x));
# Die eckigen Klammern zeigen, da"s der output eine Liste ist.
# Damit k"onnen nur solche Maple-Befehle etwas anfangen, in deren 
# Beschreibung ausdr"ucklich erw"ahnt ist, dass Listen akzeptiert
# werden, auch wenn die Liste nur ein einziges Element enth"alt. Wenn
# man den Ausdruck aus der Liste herausholen will, kann man das im Fall
# der einelementigen Liste entweder durch Aufrufen des ersten Elements
# tun oder durch Herausholen aller Elemente mittels "op".
> op(1,");
> op("");
# Eine andere M"oglichkeit zum Herausholen von Listenelementen bietet
# der "selection operator", siehe 
> ?selection
> """[1];
# Wenn es auf die Rechenzeit ankommt, sollte man ihn dem Befehl "'op"
# vorziehen.
# Will man alle Elemente der Liste herausholen, so h"angt man
# [NULL] an:
> trigsubs(sin(a*x) - sin(b*x));  
> "[NULL];
# Hier noch der analoge Versuch mit einem Produkt aus drei Termen:
> trigsubs(sin(a*x) * sin(b*x) * sin(c*x));
# ==============================================
# "Eigenart" von "trigsubs":
> trigsubs(-sin(35*Pi/99)-sin(31*Pi/99));
# Man ist gezwungen, die Aufgabe so zu formulieren:
# 
> -trigsubs(sin(35*Pi/99)+sin(31*Pi/99));
# =============================================
# d)  Exakte Werte f"ur cos, "Typ--Abfragen" und "Numerische Evidenz".
# =============================================
# Gelegentlich w"unscht man, dass Maple exakte Berechnungen von 
# Funktionswerten liefert oder zumindest ermittelt, ob ein Funktionswert
# eine rationale Zahl ist.
# Als Beispiel betrachte cos(Pi/n) und cos(Pi/2^n)
# f"ur nat"urliches n .
> seq(cos(Pi/n), n=2..11);
> seq(cos(Pi/2^n), n=1..6);
# Ist cos(Pi/64 eine irrationale Zahl oder nicht?
> type(cos(Pi/64), rational);     
> ?type
# "Ich weiss es nicht !!"
# Boolesche Funktion
# Boolean expressions: true, false, FAIL
# Trotzdem kann man mit Maple ermitteln, ob cos(Pi/64 eine irrationale
# Zahl ist:
> cos(2*x) = expand(cos(2*x));       
# Ein Programm zur Berechnung von z(n)=cos(Pi/2^n):
# Erkl"arung der Einzelheiten folgt in Kap. 10.
> z:= proc(x) local m, result; result := 0; if
> type(x, integer) = false then FAIL else if x<1 then FAIL else if x = 1
> then result; else for m from 2 to x do sqrt(2+2*result)/2; result:= ";
> od; fi; fi; fi; end;
> seq(z(k), k=0..7);
# Hier wirkt es st"orend, dass Maple selbst"andig Abk"urzungen 
# wie "%1" einf"uhrt. Das kann man wie folgt verhindern (siehe
# auch " ?interface "): 
> interface(labelling=false);
> seq(z(k), k=0..6);
# Unser Programm soll leisten: z(n)=cos(Pi/2^n) . Pr"ufe 
# das nach, anhand der Differenz: 
> seq(cos(Pi/2^n)-z(n), n=1..5);
# F"ur n = 1,2,3 ist das richtig. Gilt es auch f"ur n = 4,5 ?
# "Heuristischer Test" durch numerisches Auswerten (evalf) mit h"ochster
# Genauigkeit:
> seq(evalf(cos(Pi/2^n)-z(n)), n=1..5);
> Digits;
> Digits:= 100;
> seq(evalf(cos(Pi/2^n)-z(n)), n=1..5);        
# (Eine Genauigkeit von 80 Stellen entspr"ache einer Gewichtsbestimmung
# des Universums auf eine Proton-Masse genau.)
# Setze "'Digits"' und "'labelling"' auf ihre Normalwerte zur"uck:
> Digits:= 10;                          
> interface(labelling=true);
# ============================================
# Nun zur"uck zum Problem Typ-Abfrage: Wir wissen jetzt, dass 
# cos(Pi/32) den Wert 
> z(5);
# hat, d.h. wenn wir zu arccos "ubergehen,
# dass  arccos(z(5)/Pi)=1/32   eine rationale Zahl ist. Aber Maple gibt,
# wenn man naiv fragt, ob diese Zahl rational ist, eine falsche Antwort:
> type(arccos(")/Pi, rational);                         
# In diesem Fall ist es unumg"anglich zu wissen, dass dies bedeutet: 
# "Ich weiss es nicht!"
# Daran ist insbesondere zu denken, wenn man Typ-Abfragen in 
# Programme einbaut:
# Nur in Falle der Antwort "true" darf auf eine eindeutige Lage
# geschlossen werden!