# Lektion 2
# Funktionen und Kurven
# © 2017  Friedrich U. Mathiak, 
# mathiak@mechanik-info.de
# 
> restart:
# Hinweis: In den folgenden Anwendungen werden zur Verringerung des Schreibaufwandes die Ditto-Operatoren eingesetzt, die es erlauben, auf  zurückliegende Rechenergebnisse zurückzugreifen. Die Operatoren werden durch % (Prozentsymbol) dargestellt.
# Die einfachste Beschreibung einer Funktion geschieht  mittels der Angabe einer  Zuordnungsanweisung (assignment statement, Symbol :=) in folgender Weise:
> f:=x^4-2*x^2-1;
# Die Variable x wirkt hier wie eine Unbekannte, da ihr kein Wert zugewiesen ist. Einen schnellen Überblick über den Verlauf  von  f  verschaffen wir uns mit dem Befehl plot
> plot(f,x);
# Sollen die Funktionswerte von  f  in einem vorgegebenen Bereich geplottet werden, dann ist wie folgt vorzugehen:
> plot(f,x=-2..2,y=-2..1);
# oder mit der Zusatzoption  plot,options(view)  im plot-Befehl:
> plot(f,view=[-2..2,-2..1]);
# Zur Definition des Befehls plot und der zugehörigen Optionen siehe auch Plot Options .
# Zur Auswertung der Funktion f an einer festen Stelle dient der Befehl subs. Die rechte Seite von   f  verbleibt dabei unverändert.
> subs(x=1,f); subs(x=-1.5,f); f;
# In Maple kann die Operatorform zur Definition von Funktionen benutzt werden: (s. h. auch operators und functional operators). Dazu existieren drei Möglichkeiten
# 1. Definition durch einen Zuordnungspfeil (arrow notation)
> fa:= x-> x^4-2*x^2-1;
# Intern sieht das in Maple so aus:
> fa := proc (x) options operator, arrow; x^4-2*x^2-1 end proc;
> fa(1);fa(-1.5);
> plot(fa,-2..2,y=-2..1);
# 
# 2. Durch Anwendung des Befehls unapply auf einen algebraischen Ausdruck 
> fu:=unapply(f,x);
> plot(fu,-2..2,y=-2..1);
# 3. Durch Erstellen einer Prozedur (s.h. auch Lektion 3)
> fp:=proc(x) x^4-2*x^2-1 end proc;
# Die Prozedur wird aufgerufen durch
> fp(1);fp(x);
# Die Grafen dieser in Operatorform geschriebenen Funktionen erhalten wir z.B. im Intervall [-0.5, 2]
> plot(fa,-0.5..2);
> plot(fu,-0.5..2);
> plot(fp,-0.5..2);
# Die Auswertung der Funktionen für den Wert x = 0 geschieht wie folgt
> fa(0),fu(0),fp(0);
# Hinweis: Durch die Definitionen der Variablen mit den Namen  f, fa, fu  und  fp  wurde auf vier verschiedene Arten immer dieselbe Funktion definiert. Das Objekt, das mit dem Namen  f  belegt wurde, ist ein Ausdruck; die Objekte mit den Namen  fa, fu, fp  sind Funktionsoperatoren, also Zuordnungsvorschriften. 
# Maple enthält bereits eine Fülle von Funktionen
> plot(sqrt,0..2,gridlines=true);
> plot(sqrt(x),x=0..2,gridlines=true);
# Auch logische Ausdrücke dürfen auf der rechten Seite einer Funktionsdefinition stehen. Dazu definieren wir die Ausdrücke
> eq_neg:=x-> x<=0; eq_pos:=x-> x>0;  
# Mit diesen logischen Ausdrücken wird mit dem Befehl select die folgende Liste selektiert 
> L:=[3.1,-7.4,0.33,-55,0];
> select(eq_neg,L);select(eq_pos,L);
# Abschnittsweise definierte Funktionen
# In der mathematischen Physik treten oft Funktionen auf, die abschnittsweise definiert sind. Dazu gehört beispielsweise die Signum-Funktion,  die an der Stelle x = 0 den Wert 0 besitzt.
> convert(signum(x),piecewise);
# Wir machen uns ein Bild von dieser Sprungfunktion
> plot(signum,gridlines=true=true);
> signum(-1);signum(0);signum(1+I);
# Der Wert der Signum-Funktion an der Stelle x = 0 kann durch die Variable _Envsignum0  geändert werden. 
> _Envsignum0:=1;signum(0);convert(signum(x),piecewise);
# Ebenfalls abschnittsweise erklärt ist die  abs-Funktion
> convert(abs(x),piecewise);
> plot(abs,scaling=constrained,gridlines=true);
> convert(abs(x),signum);
# Auch die Heaviside-Funktion Heaviside(x) gehört zu den stückweise definierten Funktionen. 
> convert(Heaviside(x), piecewise);
# Für Heaviside(0) liefert Maple einen undefinierten Ausdruck 
> Heaviside(0);
# Der Nutzer kann jedoch  der Heaviside-Funktion an der Sprungstelle x = 0  einen Wert zuweisen 
> Heaviside(0):=1;convert(Heaviside(x), piecewise); 
> plot(Heaviside(x-5),color=blue,thickness=2,gridlines=true);
# Die Signum-Funktion kann durch die Heaviside-Funktion ausgedrückt werden:
> convert(signum(x),Heaviside);
# Mit dem Befehl piecewise lassen sich stückweise stetige Funktionen abschnittsweise definieren
> q:=x->2+x/4;
> f:=piecewise(x >= 0 and x <= 4,q(x));
# Die mittels piecewise definierten Funktionen lassen sich mit dem Befehl convert in einen einheitlichen Ausdruck darstellen, der allerdings rein formal ist. Dazu benutzen wir die Heaviside-Funktion und gehen wieder auf die in Maple definierte Form zurück
> Heaviside(0):=undefined;
> convert(Heaviside(x), piecewise);
> fH:=unapply(convert(f,Heaviside),x);
> plot(fH,-2..5,color=blue,thickness=2,gridlines=true);
> fH(0);fH(4);fH(2);
# Weitere Grafen abschnittsweise definierter Funktionen sind beispielsweise
> plot([trunc(x),round(x)],x=-4..4,color=[blue,red],gridlines=true);
> plot([frac(x),floor(x),ceil(x)],x=-4..4,color=[blue,red,yellow],gridlines=true);
> plot([floor,ceil,trunc,round],-4..4,color=[red,blue,gold,magenta],gridlines=true);
# Elementare Funktionen
# 1. Potenzen
> f1:=x^2; f2:=x^3;
> plot([f1,f2],x=0..2,y=0..5,axes=boxed,gridlines=true,legend=["f1","f2"],linestyle=[solid, longdash],color=[blue,gold],legendstyle=[font=["HELVETICA",12],location=bottom]);
# 2. Ganze rationale Funktionen (Polynomfunktionen)
# Als Beispiel für ganze rationale Funktionen, die auch Polynome genannt werden, betrachten wir die (qualitative) Durchbiegung  w  eines geraden elastischen Balkens unter Dreiecksbelastung, der am linken Rand eingespannt und am rechten Rand drehbar gelagert ist. Der Definitionsbereich ist 0 } ¾ }  1. 
> w:=4*xi^2-8*xi^3+5*xi^4-xi^5;
# Auszug eines Polynom-Koeffizienten
> coeff(w,xi,3);
# Erzeugen einer Liste sämtlicher Polynom-Koeffizienten
> coeffs(w,xi);
# Der führende Koeffizient des Polynoms
> lcoeff(w);
# Der Grad des Polynoms
> degree(w);
# Der niedrigste Grad des Polynoms
> ldegree(w);
# Der Koeffizient beim niedrigsten Grad des Polynoms
> tcoeff(w);
# Wir stellen das Polynom grafisch dar
> plot(w,xi=0..1,0..0.3,axes=boxed,gridlines=true);
# Die Zerlegung der Funktion w in Faktoren liefert
> wf:=factor(w);
# und das Ausmultiplizieren  des faktorisierten Polynoms ergibt wieder
> expand(wf);
# Die grafische Ausgabe der Verschiebungsfunktion, auch außerhalb des Definitionsgebietes, liefert der Befehl
> plot(w,xi=-0.5..2.5,axes=boxed,gridlines=true);
# Zur effektiven Auswertung von Polynomen per Hand wird oft das  Horner-Schema  benutzt
> convert(w,horner);
# Der Befehl  sort  bringt die Potenzen eines beliebig geordneten Polynoms in fallende (descending) und aufsteigende (ascending) Reihenfolge.
> sort(w,xi,descending);
> sort(w,xi,ascending);
# Weiterführende Kommandos zur Bearbeitung von  Polynomen findet man im Paket  
> with(PolynomialTools);
# Beispiele dazu sind:
> CoefficientList(w,xi);CoefficientVector(w,xi);
# Gebrochen rationale Funktionen sind Quotienten zweier rationaler Funktionen (Polynome). Die folgende Funktion s = p[1]/p[2]; stellt eine  echtgebrochene rationale Funktion dar
> p1:=1-x^2;p2:=x^4-3*x^2+1;
> s:=p1/p2;
> factor(s);
# Wir verschaffen uns einen Überblick über den Verlauf der Funktion
> plot(s,x=-3..3,y=-2..2,gridlines=true,scaling=constrained);
# Eine echtgebrochene rationale Funktion f(x) = Z(x)/N(x) lässt sich schrittweise in eine Summe von Teil- oder Partialbrüchen zerlegen. Dazu werden die Nullstellen des Nennerpolynoms N(x) benötigt. Die Anzahl der Nullstellen ist dann auch die Anzahl der Partialbrüche. Die genauen Werte der Nullstellen des Nenners, die hier alle reell sind, liefert uns der Befehl
> solve(denom(s),x);
# Das funktioniert auch mit dem Befehl
> SolveTools[Polynomial](denom(s),x);
# Die Dezimaldarstellung der obigen Sequenz wir erzeugt mit
> fsolve(denom(s),x);
# Die Partialbruchdarstellung von s ist
> convert(s,parfrac,x); 
# Da der Nenner mittels Ganzzahlen nicht weiter faktorisiert werden kann, teilen wir Maple mit, dass dieser die irrationale Zahl sqrt(5) enthält 
> convert(s,parfrac,x,sqrt(5));
# Die Dezimaldarstellung hätten wir auch ohne Zusatzinformation sofort wie folgt erhalten:
> convert(evalf(s),parfrac,x);
# 3. Irrationale algebraische Funktionen
# Irrationale algebraische Funktionen sind Funktionen mit gebrochenem Exponenten (z.B. 1/2 bei der Quadratwurzel), wobei die unabhängige Variable auch unter dem Wurzelzeichen auftritt.
> x:='x':
> w:=unapply(x*(1+sqrt(1+x^2)),x);
> plot(w(x),x=-5..5,gridlines=true);
# Um das Verhalten der Funktion  in der Umgebung des Ursprungs zu studieren, entwickeln wir w(x) an der Stelle x = 0 in eine Potenzreihe und wandeln diese anschließend in ein Polynom um.
> series(w(x),x=0,5); p3:=unapply(convert(%,polynom),x);
# In der Umgebung des Nullpunktes verhält sich w(x) näherungsweise linear. Für große Werte von x dagegen nichtlinear. 
> plot([w(x),p3(x)],x=-2..2,gridlines=true,legend=["w(x)","p3(x)"],color=[red,blue],linestyle=[solid, longdash],legendstyle=[font=["HELVETICA",10],location=bottom]);
# 4. Die Exponentialfunktion 
# Funktionen vom Typ  y = ax  (a > 0, a ` 1)  werden Exponentialfunktionen genannt. Speziell für a = e (Eulersche Zahl) sprechen wir von der Exponentialfunktion exp
> restart:
> exp(x);
# Der Graf dieser Funktion ist
> plot(exp(x),x=-2..2,axes=boxed,gridlines=true,thickness=2);
# Eine Reihenentwicklung an der Stelle x = 0 ergibt
> series(exp(x),x=0);
# Die  Eulersche Zahl e erhalten wir mit
> exp(1);  evalf(%); 
# Eine spezielle Exponentialfunktion ist die Abklingfunktion (radioaktiver Zerfall, Entladung eines Kondensators, abklingende Schwingung)
> (1/exp(1))^x;
> plot(%,x=0..5,gridlines=true,thickness=2,axes=boxed);
# Das Argument von  exp  kann auch komplex sein
> evalc(exp(1+Pi/2*I)); evalf(%);
> simplify(evalc(exp(x+I*y)));
# 5. Der Logarithmus
# Der natürliche Logarithmus  ln ist die Umkehrfunktion der Exponentialfunktion exp. 
> exp(ln(x));
> x1:=ln(exp(x));     simplify(x1);
# Der Befehl simplify allein führt hier ohne Zusatzinformationen nicht zum Ziel, denn x könnte ja auch komplex sein. Siehe hierzu  auch simplify/details . Wenn wir allerdings das Ergebnis als reell voraussetzen, dann kommt
> simplify(x1) assuming real;
# Wir prüfen einige Rechenregeln für Logarithmen. Zur Vereinfachung der Ausdrücke sind im Befehl simplify wieder zusätzliche Angaben erforderlich
> l1:=ln(u^n*v^m); l2:=simplify(l1) assuming positive;
# oder
> l3:=simplify(l1,symbolic);
# Die Umkehrung von  expand  ist der  Befehl combine 
> combine(l2,ln,anything,symbolic);
# Weitere Beispiele sind
> l4:=2*ln(y)-ln(z); 
> combine(l4,ln) assuming y > 0 and z > 0;
> l5:=3*ln(2)+2*ln(5);
> combine(l5,ln);
# Der Logarithmus log zu einer beliebigen Basis b wird von Maple durch natürliche Logarithmen  ausgedrückt:
> b:='b':
> log[b](x);
> log[exp(1)](x); log[10](x); log[2](x);
> log[exp(1)](1000), log[10](1000), log[2](1000);
> evalf(%);
# Der Zusammenhang zwischen zwei Variablen x und y sei durch ein Potenzgesetz gegeben. 
> y = x^b;
# Bei dem obigen Ausdruck handelt es sich um eine Gleichung und nicht um eine Wertzuweisung, deshalb fehlt der Doppelpunkt nach dem Gleichheitszeichen. Wir logarithmieren beide Seiten dieser Gleichung und verwenden dazu den Befehl map. Dabei wird eine Prozedur auf jeden Operanden des Ausdrucks angewandt, hier also auf beide Seiten der Gleichung.
>    
> map(ln,%); 
> simplify(%) assuming x>0, y>0, b>0;
# Zwischen den Logarithmen von y und x besteht offensichtlich ein linearer Zusammenhang, was Anlass dazu gibt, die grafische Darstellung von y = xb  doppeltlogarithmisch vorzunehmen. Das gelingt mit dem Befehl loglogplot aus dem Paket plots. Wir varieren dabei den Exponenten b.
> plots[loglogplot]([seq(x^b,b=[-1,-1/2,0,1/2,1])],x=0.1..10,axes=boxed,gridlines=true,legend=["b=-1","b=-1/2","b=0","b=1/2","b=1"],legendstyle=[font=["HELVETICA",12],location=right]);
# 6. Die Trigonometrischen Funktionen
# Sehen wir uns die Graphen der trigonometrischen Funktionen an:
> plot([sin,cos],-Pi..2*Pi,title ="\nSinus- u. Cosinusfunktion\n",legend =["Sinus","Cosinus"],titlefont=["ROMAN",15],tickmarks=[spacing(1/2*Pi),default],color=[red,blue],thickness=2,axes=boxed,gridlines=true);
> plot([tan,cot],-Pi..2*Pi,-4..4,title ="\nTangens- u. Cotangensfunktion\n",legend =["Tangens","Cotangens"],titlefont=["ROMAN",15],tickmarks=[spacing(1/2*Pi),default],color=[red,blue],thickness=2,axes=boxed,gridlines=true);
# Maple ermöglicht uns, die Additionstheoreme der trigonometrischen Funktionen zu überprüfen. Hier einige Beispiele
> s1:=sin(alpha+beta); s2:=expand(s1); s3:=combine(s2,trig); 
> x:='x':
> s4:=8*cos(x)^3*sin(x)-4*cos(x)*sin(x); combine(%,trig);

> cos(2*alpha); expand(%);
> cos(alpha)^2+sin(alpha)^2; simplify(%);
> tan(alpha/2);  convert(%,sincos);
> expand(cot(3*x));
> combine(cos(x)^3,trig);
> expand(sin(2*x));
# Das Argument einer trigonometrischen Funktion kann auch komplex sein:
> z:=a+I*b;
> cos(z); expand(%); 
# Wir drücken cos(z) durch die Exponentialfunktion aus
> convert(%,exp);
# 7. Die Arkusfunktionen
# Die Arkusfunktionen sind die Umkehrungen der trigonometrischen Funktionen. 
# Beispiel:  y = arcsin x  für x = sin y bedeutet: y ist der Winkel im Bogenmaß, dessen Sinus den Wert x besitzt. Entsprechendes gilt für y = arccos x. 
# Der Definitionsbereich von y = arcsin(x)  ist -1 d x d 1 und ihr Wertevorrat ist -À/2 d y d À/2. 
# Der Definitionsbereich von y = arccos(x)  ist -1 d x d 1 und ihr Wertevorrat ist     0 d y d À. 
# Wir stellen beide Funktionen grafisch dar. 
> plot([arcsin(x),arccos(x)],x=-1..1,color=[black,blue],legend=["arcsin","arccos"],scaling =constrained,gridlines=true,scaling=constrained,axes=boxed,legendstyle=[font=["HELVETICA",12],location=right]);
# Die  kartesischen (x,y)-Koordinaten eines Punktes P sind mit den Polarkoordinaten  r, Õ  durch die Formeln x = r cos(Æ), y = r sin(Õ) gegeben. Um den Winkel Õ zu berechnen, bilden wir y/x = tan(Õ) und  damit durch Umkehrung Õ = arctan(y/x).
> x:=-2: y:=2: q:=y/x; phi:=arctan(q);
# Das Ergebnis liefert einen Punkt im 4. Quadranten, obwohl der Punkt P mit den eingegebenen Koordinaten im 2. Quadranten liegt. Das korrekte Ergebnis erhalten wir, wenn wir der Funktion arctan beide Argumente y und x übergeben.
> phi:=arctan(y,x);evalf(convert(%,degrees));
# Wir prüfen das Ergebnis und beachten dazu r = sqrt(x^2+y^2);
> r:=sqrt(x^2+y^2);
> x:=r*cos(phi);y:=r*sin(phi);
# Die komplexe Zahl, deren Cosinus den Wert 2 besitzt ist
> arccos(2.);cos(%);
# 8. Die Hyperbelfunktionen
> x:='x':
> plot([sinh(x),cosh(x),tanh(x),coth(x)],x=-Pi..Pi,-Pi..Pi,color=[black,red,blue,green],legend=["sinh","cosh","tanh","coth"],thickness=2,gridlines=true,axes=boxed);
# Die Hyperbelfunktionen lassen sich durch die Exponentialfunktion ausdrücken
> convert([sinh(x),cosh(x),tanh(x),coth(x)],exp);
# Wie die folgenden Darstellungen zeigen, kann der Hyperbeltangens mit wachsendem Faktor a  als stetige Approximation der unstetigen  signum-Funktion angesehen werden.
> a:='a':
> f:=unapply(tanh(a*x),a,x);
> plot([seq(f(i,x),i=1..3)],x=-5..5,color=[red,blue,yellow],legend=["a = 1","a = 2","a = 3"],thickness=2,axes=boxed,
> gridlines=true);
# Maple gestattet uns die Darstellung des Hyperbeltangens über die ganze reelle Achse:
> plot(tanh(x),x=-infinity..infinity,thickness=2);
# Wir vergleichen den Grafen der Hyperbelcosinus-Funktion (Kettenlinie) mit einer quadratischen Parabel, die wir aus der Reihenentwicklung von cosh(x) um den Punkt x = 0 erhalten, und es zeigt sich, dass für kleine Beträge von x der cosh   gut durch eine Parabel zweiten Grades approximiert wird.
> series(cosh(x),x);
> p3:=convert(series(cosh(x),x,3),polynom);
> plot([cosh(x),p3],x=-2..2,1..2.5,color=[red,blue],legend=["cosh","Parabel"],thickness=2,axes=boxed,gridlines=true);
# Der Befehl  logplot aus dem Paket  plots  bietet die Möglichkeit,  eine logarithmische Skala auf der vertikalen Achse zu verwenden. 
> plots[logplot]([cosh(x),1+x^2/2],x=-3..3,color=[red,blue],legend=["cosh","Parabel"],thickness=2,gridlines=true);
# 9. Die Areafunktionen
# Achtung: In Maple schreibt man arcsinh, arccosh, arctanh und arccoth!
# Die Area-Funktionen sind die Umkehrfunktionen der Hyperbelfunktionen.
# Beispiel: Areasinusfunktion (Area sinus hyperbolicus) y = arcsinh x  für  x = sinh y. 
# Der Definitionsbereich von y = arcsinh(x)  ist - d x d  und ihr Wertevorrat ist   - d y  d . 
# Der Definitionsbereich von y = arccosh(x)  ist  1 d x <  und ihr Wertevorrat ist     0  d y  d . 
# Der Definitionsbereich von y = arctanh(x)  ist -1< x < 1 und ihr Wertevorrat ist     - d y d . 
# Der Definitionsbereich von y = arccoth(x)  ist       |x| >1  und ihr Wertevorrat ist            |y | >0. 
> plot([sinh(x),arcsinh(x)],x=-5..5,-5..5,scaling=constrained,color=[red,blue],thickness=2,legend=["sinh","arcsinh"],gridlines=true,axes=boxed);
# Der Definitionsbereich der Funktion y = arsinh x ist  - < x < +  und ihr Wertebereich  - < y <+.
# Bei der Funktion cosh(x) treffen wir folgende Verhältnisse an:
> plot([cosh(x),arccosh(x)],x=-5..5,-5..5,
> color=[red,blue],thickness=2,legend=["cosh","arcosh"],gridlines=true,axes=boxed);
# Der Definitionsbereich der Funktion y = arcosh x  ist 1 d  x < + und ihr Wertebereich  0 d y < + bzw.  - < y d 0. Dieser Ast, der bei der Spiegelung von cosh x an der Winkelhalbierenden für negative Werte von x entsteht, wird von Maple nicht dargestellt. Die negative Zahl -y löst ebenfalls die Gleichung x = cosh(-y), wie das folgende Beispiel zeigt: 
> arccosh(cosh(-2));arccosh(cosh(2));
# Die Areafunktionen lassen sich durch logarithmische Funktionen ausdrücken: 
> convert([arcsinh(x),arccosh(x),arctanh(x),arccoth(x)],ln);
> 
;
# 
# 
# 
# 
