# KAPITEL 17: Funktionen definieren und graphisch darstellen.
# ===========================================
# a) Definieren von Funktionen
# -----------------------------------
# Zur Darstellung von Funktionen haben wir bisher drei
# verschiedene Formate verwendet:
# 1) expression (=Formel, Ausdruck),
# 2) arrow--notation (Verwendung des arrow - Operators),
# 3) procedure (vom Benutzer geschriebenes oder Maple - internes
# Programm).
#
# Je ein Beispiel:
> expr:=1-x/(1+x^2);
> arrow:=y->1+2*y+2*y^2+2*y^3;
> sin;
# Streng genommen handelt es sich bei "expr" nicht um
# eine Funktion sondern um den Funktionswert an der Stelle x.
# Das macht sich bemerkbar, wenn man den Befehl "plot"
# anwendet: Die Variable x muss explizit angesprochen werden.
> plot(expr, x=-3..3);
# Behandelt man dagegen den Namen "expr" wie einen
# Funktionsnamen, so wird der Befehl nicht verstanden:
> plot(expr, -3..3);
Plotting error, empty plot
# F"ur die Typen "arrow" und "procedure" gen"ugt zum
# plotten der Name:
> plot(arrow, -3..3, 0..20);
> plot(sin, -3..3, -1.2..1.2);
# Zugleich lassen sie sich aber auch wie expressions behandeln,
# d.h. auch die folgenden Befehle werden akzeptiert:
> plot(arrow(x), x=-3..3, y=0..20):
> plot(sin(x), x=-3..3, y=-1.2..1.2):
# Entsprechend unterschiedlich ist das Verhalten beim Berechnen
# einzelner Funktionswerte (und bei vielen anderen Maple-Befehlen): In
# einen Ausdruck kann nicht ohne weiteres ein spezielles Argument
# eingesetzt werden:
> expr(0);
# Man muss sich behelfen, indem man entweder der Variablen x
# den gew"unschten Wert zuweist:
> x:=0; expr; x:='x';
# oder man kann die "subs" -Funktion verwenden, um formal
# x=0 in den Ausdruck zu substituieren:
> subs(x=0, expr);
# Bei den anderen beiden Typen kann dagegen der Wert an der Stelle 0 so
# abgerufen werden, wie man es von einer Funktion erwartet:
> arrow(0);
> sin(0);
# "Uberg"ange
# =========
# Der Befehl "unapply" bewirkt die Umwandlung eines Ausdrucks
# in eine Funktion in "arrow--notation". Da der Ausdruck keine
# Information dar"uber enth"alt, welches die Variable sein soll (es
# k"onnten mehrere Kandidaten daf"ur vorhanden sein), muss "unapply"
# stets als zweite Eingabe die gew"unschte Variable enthalten:
> unapply(expr,x);
# Wenn man keinen Funktionsnamen gew"ahlt hat, entsteht eine "anonyme
# Funktion", wie Heck [1], S. 70, 211, das nennt. Will man die Funktion
# mehrmals benutzen, so sollte man ihr besser einen Namen geben:
> funktion:=";
# Jetzt k"onnen Funktionswerte eingesetzt werden:
> funktion(I);funktion(1);
Error, (in funktion) division by zero
# und auch der folgende Befehl wird akzeptiert:
> plot(funktion, -3..3);
# Ein zweiter "Ubergangsbefehl verwendet zwar den
# "arrow--operator", erzeugt aber ein Programm:
> f:=(x,a) -> if x plot(1/x, x=-1..1, y= -100..100,
> axes=none);
# Im Normalfall, d.h. wenn die darzustellende Funktion durch eine
# "expression" gegeben ist, kann man diese Linie durch
# Hinzuf"ugen der Option "discont=true" beseitigen:
> plot(1/x, x=-1..1, y= -100..100,
> discont=true, axes=none);
# Wenn eine Funktion nicht durch einen einzigen Ausdruck gegeben,
# sondern st"uckweise definiert ist, ist beim Plotten zu beachten:
# 1) Maple verlangt "unevaluation quotes", falls die
# Funktion durch ein Programm definiert ist, d.h. wenn "Boolesche
# Ausdr"ucke" in der Definition vorkommen.
# 2) Maple akzeptiert jetzt i.a. nicht mehr die Option
# "discont = true", so dass die hinzugef"ugten senkrechten
# Linien auf andere Weise beseitigt werden m"ussen.
#
# Beispiel: Eine st"uckweise konstante Funktion mit Sprungstellen
# (Treppenfunktion). Wir diskutieren vier M"oglichkeiten:
#
# i) Mittels des obigen Programms f definiere eine Stufe
# der H"ohe 1 bei x=a und setze die Treppe daraus zusammen.
# ii) Verwenden der Heaviside--Funktion als Einheitsstufe.
# iii) Verwenden des Befehls "piecewise".
# iv) Entfernen der Erg"anzungslinien durch Zerlegen der
# Grafik in Einzelbilder.
#
# Zu i):
# Der Befehl "sum" verlangt "unevaluation quotes":
> f:=proc(x,a) if x g:=x->f(x,-4)-5+sum('f'(x,m),m=-3..5);
# Beim "plot" -Befehl sind "unevaluation quotes" n"otig,
# falls der Ausdruck g(x) angesprochen wird:
> plot('g(x)', x=-6..6);
# Es kann auf die "unevaluation quotes" verzichtet werden, wenn der
# Funktionsname g angesprochen wird.
> plot(g, -6..6);
> plot(g, -6..6, discont=true);
Error, (in plot) discontinuous plotting only for expressions
# ============================================
# Zu ii):
# Durch einen Versuch mit der Heaviside--Funktion finden wir, dass Maple
# deren Werte als "expressions" akzeptiert und die senkrechten Striche
# beseitigt:
> plot(Heaviside(x), x= -2..2, discont = true, axes = none);
# Allerdings ist hier der Zugang mittels des Funktionsnamens gesperrt:
> plot(Heaviside, -2..2, discont = true, axes = none);
Error, (in plot) discontinuous plotting only for expressions
# Wiederhole obige Definition von g mit f ersetzt durch "Heaviside"
# und lasse die "unevaluation quotes" weg:
> f:= (x,m) -> Heaviside(x-m);
> g:= x -> f(x,-4) - 5 + sum(f(x,m), m= -3..5);
> plot(g(x), x = -7..8, discont = true);
# "Ahnlich verhalten sich die Sprungfunktionen "trunc, round, frac,
# floor" und "ceil". Die Funktion "floor" ist auch als
# Gauss--Klammer oder "gr"osste--ganze" -Funktion bekannt.
# Siehe "?trunc" f"ur die "ubrigen Definitionen.
> plot(frac(x), x = -2..3, discont = true);
# Durch geschickte Verwendung der Funktionen "Heaviside, trunc, floor"
# u.s.w. und Kombination mit anderen Funktionen kann man versuchen, auch
# komplizierte zusammengesetzte Funktionen darzustellen. Aber dann wird
# die Option "discont = true" eventuell nicht mehr angenommen:
> plot(x*floor(1/x), x=0..1, discont = true);
Error, (in plot/discontplot/alldisconts) wrong number (or type) of
parameters in function type
# Es gibt jedoch zwei andere M"oglichkeiten.
# ============================================
# Zu iii):
# --------
# Die Syntax f"ur den Befehl "piecewise" wird unter
# "?piecewise" so erkl"art:
# Calling Sequence:
# piecewise(cond_1,f_1, cond_2,f_2, ..., cond_n,f_n, f_otherwise)
# With the piecewise function it is possible to express
# piecewise-continuous functions. The semantics are as in a case
# statement: if cond_1 is true then f_1, else if cond_2 is true
# then _2, and so on. f_otherwise gives a default case which
# corresponds to all conditions being false. The default for
# f_otherwise is 0.}
# Also ist der folgende Befehl geeignet, nacheinander die Werte einer
# Funktion"Arch" in den Bereichen
# -infinity Arch:=x->piecewise(x<-11,6,x<-10,0,x<-4,6+sqrt(9-(x+7)^2),x<-3,0,x<3,
> 6+sqrt(9-x^2),x<4,0,x<10,6+sqrt(9-(x-7)^2),x<11,0,6);
> plot(Arch, -12..12,scaling=constrained);
# Richtig ist: (Vorsicht: braucht Zeit!)
> plot(Arch(x), x=-12..12, scaling=constrained, discont=true);
# Auch der Befehl mit Ungleichungspaaren wird akzeptiert:
> Arch:=x->piecewise(x<-11,6,x>=-11 and
> x<-10,0,x>=-10 and x<-4,6+sqrt(9-(x+7)^2),x>=-4 and x<-3,0,x>=-3 and
> x<3,6+sqrt(9-x^2),x>=3 and x<4, 0,x>=4 and
> x<10,6+sqrt(9-(x-7)^2),x>=10 and x<11,0, 6);
> Arch(x);
> plot(Arch,-12..12,scaling=constrained);
# Grunds"atzlich verschieden verh"alt sich die folgende Konstruktion:
> ARCH:=piecewise(x<-11,6,x<-10,0,x<-4,6+sqrt(9-(x+7)^2),x<-3,0,x<3,
> 6+sqrt(9-x^2),x<4,0,x<10,6+sqrt(9-(x-7)^2),x<11,0, 6);
{ 6 x < -11
{
{ 0 x < -10
{
{ 2 1/2
{ 6 + (-40 - x - 14 x) x < -4
{
{ 0 x < -3
{
ARCH := { 2 1/2
{ 6 + (9 - x ) x < 3
{
{ 0 x < 4
{
{ 2 1/2
{ 6 + (-40 - x + 14 x) x < 10
{
{ 0 x < 11
{
{ 6 otherwise
# Hier kann kein Funktionswert abgerufen werden:
> ARCH(7);
/{ 6 x < -11 \
|{ |
|{ 0 x < -10 |
|{ |
|{ 2 1/2 |
|{ 6 + (-40 - x - 14 x) x < -4 |
|{ |
|{ 0 x < -3 |
|{ |
|{ 2 1/2 |(7)
|{ 6 + (9 - x ) x < 3 |
|{ |
|{ 0 x < 4 |
|{ |
|{ 2 1/2 |
|{ 6 + (-40 - x + 14 x) x < 10 |
|{ |
|{ 0 x < 11 |
|{ |
\{ 6 otherwise/
> plot(ARCH, -12..12, scaling=constrained);
Plotting error, empty plot
> plot(ARCH(x),x=-12..12,scaling=constrained);
> plot(ARCH(x),x=-12..12, scaling=constrained, discont=true);
Error, (in discont/discontR) does not know about function, piecewise(x
< -11,6,x < -10,0,x < -4,6+(-40-x^2-14*x)^(1/2),x < -3,0,x <
3,6+(9-x^2)^(1/2),x < 4,0,x < 10,6+(-40-x^2+14*x)^(1/2),x < 11,0,6)
# ===========================================
# Zu iv):
# --------
# Als vierte M"oglichkeit bleibt das Zerlegen einer Grafik unter
# Verwendung von Plot-Strukturen und des "display" - Befehls.
# Die unter ii) bereits erw"ahnte Funktion f(x) = x*floor(1/x) hat im
# Intervall 0<=x, x<1 Sprungstellen
# bei x = 1/n f"ur n=1,2,3, . . . . Damit dort keine
# Erg"anzungslinien eingezeichnet werden k"onnen, nutzen wir die
# F"ahigkeit von Maple, mehrere Bilder "ubereinander abzubilden. Das
# setzt voraus, dass die einzelnen Bilder "Plot--Strukturen" sind.
# Wir stellen das Bild des Ausschnitts von x=1/n bis x=1/(n-1) als den
# Wert einer Funktion "h" an der Stelle n dar und verfahren wie in
# Kapitel 6.
# Statt "display3d" ist f"ur zweidimensionale Bilder "display"
# zu verwenden. Auch hier mu"s zuvor "with(plots)" ausgef"uhrt werden.
# Damit die senkrechten Linien verschwinden, verk"urzen wir das
# Intervall geringf"ugig auf [1/n+0.001, 1/(n-1)]. Damit ist
# sichergestellt, dass Maple im Bild h(n) den Wert von f(1/n) nicht zur
# Kenntnis nimmt:
> h:= n ->
> plot(x*floor(1/x),x=1/n+.001..1/(n-1));
> type(h(2),PLOT);
> with(plots):
> display({seq(h(n),n=2..8)});
# F"ur kleine Werte von x sind noch senkrechte
# Verbindungen vorhanden. Diese beseitigen wir, indem wir das n -te
# Intervall auch am oberen Ende ein wenig verk"urzen:
> h:= n-> plot(x*floor(1/x),x=1/n+.001..1/(n-1)-.001);
> display({seq(h(n),n=2..12)}, axes=none);
# Obwohl aus den Bild ersichtlich ist, dass die Funktion den
# rechtsseitigen Limes 1 an der Stelle 0 hat, kann Maple dies nicht
# mittels des limit -Befehls ermitteln:
> simplify(limit(x*floor(1/x), x=0, right));
>