# 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  zurckliegende Rechenergebnisse zurckzugreifen. 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 zugehrigen 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 unverndert.
> 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 Mglichkeiten
# 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 fr 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 enthlt bereits eine Flle von Funktionen
> plot(sqrt,0..2,gridlines=true);
> plot(sqrt(x),x=0..2,gridlines=true);
# Auch logische Ausdrcke drfen auf der rechten Seite einer Funktionsdefinition stehen. Dazu definieren wir die Ausdrcke
> eq_neg:=x-> x<=0; eq_pos:=x-> x>0;  
# Mit diesen logischen Ausdrcken 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 gehrt 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  gendert werden. 
> _Envsignum0:=1;signum(0);convert(signum(x),piecewise);
# Ebenfalls abschnittsweise erklrt ist die  abs-Funktion
> convert(abs(x),piecewise);
> plot(abs,scaling=constrained,gridlines=true);
> convert(abs(x),signum);
# Auch die Heaviside-Funktion Heaviside(x) gehrt zu den stckweise definierten Funktionen. 
> convert(Heaviside(x), piecewise);
# Fr 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 ausgedrckt werden:
> convert(signum(x),Heaviside);
# Mit dem Befehl piecewise lassen sich stckweise 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 zurck
> 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 fr 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 smtlicher Polynom-Koeffizienten
> coeffs(w,xi);
# Der fhrende 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 auerhalb 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);
# Weiterfhrende 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) lsst sich schrittweise in eine Summe von Teil- oder Partialbrchen zerlegen. Dazu werden die Nullstellen des Nennerpolynoms N(x) bentigt. Die Anzahl der Nullstellen ist dann auch die Anzahl der Partialbrche. 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) enthlt 
> convert(s,parfrac,x,sqrt(5));
# Die Dezimaldarstellung htten 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 unabhngige 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 anschlieend in ein Polynom um.
> series(w(x),x=0,5); p3:=unapply(convert(%,polynom),x);
# In der Umgebung des Nullpunktes verhlt sich w(x) nherungsweise linear. Fr groe 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 fr 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 natrliche Logarithmus  ln ist die Umkehrfunktion der Exponentialfunktion exp. 
> exp(ln(x));
> x1:=ln(exp(x));     simplify(x1);
# Der Befehl simplify allein fhrt hier ohne Zusatzinformationen nicht zum Ziel, denn x knnte ja auch komplex sein. Siehe hierzu  auch simplify/details . Wenn wir allerdings das Ergebnis als reell voraussetzen, dann kommt
> simplify(x1) assuming real;
# Wir prfen einige Rechenregeln fr Logarithmen. Zur Vereinfachung der Ausdrcke sind im Befehl simplify wieder zustzliche 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 natrliche Logarithmen  ausgedrckt:
> 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 ermglicht uns, die Additionstheoreme der trigonometrischen Funktionen zu berprfen. 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 drcken cos(z) durch die Exponentialfunktion aus
> convert(%,exp);
# 7. Die Arkusfunktionen
# Die Arkusfunktionen sind die Umkehrungen der trigonometrischen Funktionen. 
# Beispiel:  y = arcsin x  fr x = sin y bedeutet: y ist der Winkel im Bogenma, dessen Sinus den Wert x besitzt. Entsprechendes gilt fr 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 prfen 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 ausdrcken
> 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 fr kleine Betrge 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 Mglichkeit,  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  fr  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 Verhltnisse 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 fr negative Werte von x entsteht, wird von Maple nicht dargestellt. Die negative Zahl -y lst ebenfalls die Gleichung x = cosh(-y), wie das folgende Beispiel zeigt: 
> arccosh(cosh(-2));arccosh(cosh(2));
# Die Areafunktionen lassen sich durch logarithmische Funktionen ausdrcken: 
> convert([arcsinh(x),arccosh(x),arctanh(x),arccoth(x)],ln);
> 
;
# 
# 
# 
# 
