Numerische Mathematik€¦ · die wie kleine Maple-Nutzerhandbuc her zu den folgenden Gebieten untersetzt mit vielen Beispielen genutzt werden k onnen. - Formeln, Ausdr uc ke und

Numerische Mathematik

Vorlesungen, Ubungen,

Algorithmen und Programme

Privatdozent Dr. rer. nat. habil. Werner Neundorf

Institut fur Mathematik

der Fakultat fur Mathematik und Naturwissenschaften

der Technischen Universitat Ilmenau

Ilmenau 2002

Datei: maplemws.ps, *.pdf

Anhang A

Anhang B

Anhang C

Arbeitsblatter in Matlab und

Maple

C.1 Matlab

Zunachst mochte ich auf die Preprints

[1] Neundorf, W.: MATLAB - Teil I: - Vektoren, Matrizen, lineare Gleichungs-

systeme. Preprint M 20/99 IfMath der TU Ilmenau, Juli 1999. [2] Neundorf, W.:

MATLAB - Teil II: - Speicheraspekte, spezielle LGS, SDV, EWP, Graphik, NLG,

NLGS. Preprint M 23/99 TUI, September 1999.

[3] Neundorf, W.: MATLAB - Teil III: - Komplexe LGS, Interpolation, Splines.Preprint M 10/00 IfMath der TU Ilmenau, Mai 2000.

[4] Neundorf, W.: MATLAB - Teil IV: - Approximation, Numerische Intergrati-

on. Preprint M 11/00 IfMath der TU Ilmenau, Mai 2000.

zu den folgenden Gebieten der numerischen Mathematik verweisen.

- Vektoren, Matrizen,- LGS, spezielle LGS, komplexe LGS, EWP, SVD,- Interpolation, Splines,- Approximation, numerische Intergration.

Dazu findet der Leser zahlreiche Matlab m-Files sowie diverse Daten- und Ergebnis-files *.m, *.ps, *.eps, *.mat auf der personlichen Homepage im Internet.Dort sind auch die Postscript-Files primer35.ps, matlab.ps der 2. bzw 3. Edi-tion des Matlab Primers.

Homepage

http://imath.mathematik.tu-ilmenau.de/∼neundorf/index de.html

Navigator → Publications → Computeralgebra → MATLAB1..4

4 Arbeitsblatter in Matlab und Maple

Zusammenstellung von Adressen - World Wide Web mit Matlab Seiten

Die TEX Quelle sowie das Postscript-File primer35.ps der 2. Edition des MatlabPrimers stehen auch mittels ftp auf ftp.math.ufl.edu im Verzeichnis pub/matlabzur Verfugung.

Die MathWorks Inc. und MathTools Ltd. entwickeln und vertreiben die Compu-tersoftware Matlab und andere Komponenten und sind naturlich mit ihrem ganzenAngebot auch im Internet zu finden.

http://www.mathworks.com/ The MathWorks Inc. Home(auch Simulink)

http://www.mathworks.com/products/matlab/ Matlab 6.1, Description,Function List, Demos u. a.

http://www.mathworks.com/products/compiler/ Matlab Compilerhttp://www.mathworks.com/support/books/ Matlab based books

http://www.mathtools.net/ The techmical computing portalhttp://www.mathtools.com/ Matlab Toolboxen von MathTools Ltd.

(auch MATCOM, MIDEVA)

http://krum.rz.uni-mannheim.de/cafgbench.html Computer Algebra Benchmarks(RZ/Uni Mannheim)

C.2 Maple

Auch hier ein Verweis auf die Preprints

[1] Neundorf, W.: Programming in Maple V Release 5. Extended Basics. PreprintM 07/99 IfMath der TU Ilmenau, Februar 1999.

[2] Neundorf, W. und B. Walther: Grafik, Animation und Ausgabeformate in

Maple V Release 5. Preprint M 12/00 IfMath der TU Ilmenau, Juni 2000.

die wie kleine Maple-Nutzerhandbucher zu den folgenden Gebieten untersetzt mitvielen Beispielen genutzt werden konnen.

- Formeln, Ausdrucke und Anweisungen,- Datenstrukturen,- Prozeduren, Programmierung,- Daten- und Programmeingabe sowie Ausgabe,- Grafik, Animation und Ausgabeformate.

Dazu findet der Leser zahlreiche Maple mws-Arbeitsblatter, m-Files (Prozeduren)sowie Daten- und Ergebnisfiles *.m, *.txt, *.c, *.res, *.pcx, *.ps, *.eps,

*.tif, *.gif auf der personlichen Homepage im Internet.

Homepage

http://imath.mathematik.tu-ilmenau.de/∼neundorf/index de.html

Navigator → Publications → Computeralgebra → MAPLE1..2

C.2 Maple 5

Zusammenstellung von Adressen - World Wide Web mit Maple Seiten

http://ist.uwaterloo.ca/ew/software/scientific/ Waterloo Maple’s,University of Waterloo Ontario Canada

http://www.maplesoft.com Maple Home Page (Waterloo Maple Inc.Advancing Mathematics): Products, publi-cations, sales, support, services, company

http://www.mapleapps.com/ The Maple Application Centerhttp://www.mapleapps.com/categories/ Maple Application Center,

whatsnew/html/SCCCmapletutorial.shtml Tutorials and Traininghttp://www.maple4students.com/main.html Maple Student Center,

Tutorialshttp://www.scientific.de/maple/maple.html Deutsche Maple Home Page

http://SunSite.informatik.rwth-aachen.de/ Maple an der RWTH Aachen bilingualmaple/maplev.html Maple 7, Einfuhrung in Maple V

Geschichte, Mandelbrotmenge u. a.http://www.mthcsc.wfu.edu/docs/ Maple Tutorial, Wake Forest University

software.html

http://www.uni-karlsruhe.de/∼Maple/ Maple Seite der Uni Karlsruhe

http://www.uni-essen.de/hrz/mathe/maple/ Maple Seite der Uni Essen

http://www.minet.uni-jena.de/∼schmitzm/ Mathematik Didaktik mit Maplemaple/index.html an FSU Jena

http://www.ikg.rt.bw.schule.de/fh/ Maple am Isolde-Kurz-Gymnasiummathe.html Reutlingen

http://www.kp.tue.bw.schule.de/maple.html Maple am Kepler-Gymnasium Tubingen

http://saaz.lanl.gov/maple/Maple Home.html A Maple Tutorial from Los Alamos NL(The Cluster Team Pres.)

http://saaz.lanl.gov/maple/ Maple on the WebMaple Page13.html

http://web.mit.edu/afs/athena/software/ Software at MIT Cambridge, MA USA,maple/www/home.html Maple

http://www-math.cc.utexas.edu/math/Maple/ Maple index page, UT Austin

http://www.math.villanova.edu/archives/ Why MAPLE? Department of Math.why maple.htm Sciences, Villanova University PA, USA

http://math.unm.edu/∼wester/cas review.html M. Wester Hompage Albuquerque USA,A Critic of the Math. Abilities of CAS

http://www.SymbolicNet.org/ Symbolic Math. Computation InformationCenter, Kent State University USA

ftp://ftp.unibe.ch/pub/Maple/algcurve/ AlgCurve Package maintainedat University Bern CH

ftp://galois.maths.qmw.ac.uk/pub/mapledoc Maple Introduction

ftp://ftp.hprc.utoronto.ca/pub/ednet/maths/ Experiments using Maplemaple/readme.html


C.3 Kap.4 - Eigenwertproblem und Singularwert-

zerlegung

Konvergenzverbesserung der simultanen Vektoriteration durch Verschie-

bung und Aufspreizung des Spektrums

Nach dem 1. Schritt der Spektralverschiebung werden wir die dominanten EW durchein Aufspreizen mehr auseinanderziehen und somit im weiteren die Konvergenzrateverbessern. Dazu verwenden wir die Tschebyscheff-Polynome Tn(x) nicht wie gewohntim Intervall [−1, 1], sondern außerhalb des Intervalls. Fur x > 1 steigen die Polynomemit wachsendem Grad immer steiler an.

Darstellung der ersten Tschebyscheff-Polynome und zugehorigen gespreizten Eigen-werte mittels Maple.

Datei: nm4ip1.mws

Spektralverschiebung und Spreizung mit Tschebyscheff-Polynomen

> restart:

> with(plots):

> with(plottools):

> with(orthopoly); # orthopoly package

T(n,x) generates the nth Chebyshev polynomial of the first kind.

> # Arbeitsverzeichnis

> pfad := ‘D:/Neundorf/Nwptexte/Math93/‘;

> # Graphic output files

> name1 := ‘nm4ip1.ps‘;



> datei1 := cat(pfad,name1);



Suppose we want to manipulate symbolically the Chebyshev polynomials

of the first kind Tn(x). We can represent these in Maple as T(n,x).

Recall that Tn(x) satisfies the linear recurrence T0(x)=1, T1(x)=x,

and Tn(x) = 2 x T{n-1}(x) - T{n-2}(x).

Tschebyscheff-Polynome

> for i from 0 to 5 do

> T(i,x);

> od;

C.3 Kap.4 - Eigenwertproblem und Singularwertzerlegung 7

> for i from 0 to 5 do

> p[i]:=plot(T(i,x),x=0..2,color=black):

> od:

> t0 := textplot([[1.9,14,‘T2(x)‘],

> [1.9,34,‘T3(x)‘],[1.9,95,‘T4(x)‘],[1.9,330,‘T5(x)‘]]):

> plots[display]([seq(p[i],i=0..5),t0], tickmarks=[4,4], thickness=2,

> title=‘Tschebyscheff-Polynome Ti(x), 0<=x<=2, i=0..5‘);

> interface(plotdevice=ps,

> plotoutput=datei1,

> plotoptions=‘width=640,height=480‘);

> plots[display]([seq(p[i],i=0..5),t0], tickmarks=[4,4], thickness=2,

> title=‘Tschebyscheff-Polynome Ti(x), 0<=x<=2, i=0..5‘);

> interface(plotdevice=win);

EW lambda(i)

> s:=1:

> la1:= la -> la-s:

> la2:= la -> (la-s)^2-s^2/2:

> la3:= la -> (la-s)^3 -3/4*(la-s)*s^2:

> p1:=plot(la1(la),la=0..3,color=black):



> t1 := textplot([[2.8,1.5,‘lambda(1)‘],[2.8,2.8,‘lambda(2)‘],

> [2.8,6,‘lambda(3)‘]]):

> plots[display]([p1,p2,p3,t1], tickmarks=[4,8], thickness=2,

> title=‘lambda(i)(la), 0<=la<=3, i=1,2,3‘);




> plots[display]([p1,p2,p3,t1], tickmarks=[4,8], thickness=2,

> title=‘lambda(i)(la), 0<=la<=3, i=1,2,3‘);


EW 2^(i-1)*lambda(i)/s^i

> las1:= r -> r-1:

> las2:= r -> 2*(r-1)^2-1:

> las3:= r -> 4*(r-1)^3 -3*(r-1):

> ps1:=plot(las1(r),r=0..2.5,color=black):



> ps4:=plot([[2,0],[2,1]],color=black):


> t2 := textplot([[2.35,1.0,‘lambdas(1)‘],

> [2.35,2.8,‘lambdas(2)‘],[2.2,6,‘lambdas(3)‘]]):

> plots[display]([ps1,ps2,ps3,ps4,t2], tickmarks=[4,8], thickness=2,

> title=‘lambdas(i)(r), 0<=r<=2.5, i=1,2,3‘);




> plots[display]([ps1,ps2,ps3,ps4,t2], tickmarks=[4,8],

> thickness=2,

> title=‘lambdas(i)(r), 0<=r<=2.5, i=1,2,3‘);


QR-Algorithmus

Unter Verwendung des Maple-Kommandos QRdecomp fur die QR-Faktorisierungwerden die Diagonalelemente von R positiv skaliert. Bei fortschreitender Iterationwerden die symbolischen Rechnungen immer aufwendiger und “langer“, damit lang-samer. In nachfolgenden Beispielen wird der QR-Algorithmus mit der Householder-Transformation durchgefuhrt, nur bei Beispiel 1 sind beide Varianten zum Vergleichangegeben.Zu den EWP werden die entsprechende Informationen ausgegeben wie det(A), EW,EV, charakteristisches Polynom, teilweise auch Zwischenergebnisse des QR-Algorith-mus.

Datei: nm4ip2.mws

QR-Algorithmus

> restart:

> with(linalg):

1.Beispiel

Matrix und EW, EV

> n:=4:

> A := matrix(n,n,[[ 1,-1, 1, 2],

> [-1, 2, 0, 1],

> [ 1, 0,-1, 1],

> [ 2, 1, 1, 0]]):

> det(A);

> vecs:=’vecs’:

> lambda := evalf(Eigenvals(A,vecs));

> print(vecs);

> E:=diag(1,1,1,1):

> P4:=sort(det(A-x*E),x);


QR-Transformation

> R := QRdecomp(A, Q=’q’, rank=’r’);

> r;

> evalm(q);

> evalm(R &* q);

> evalf(evalm(R &* q));

Mehrere Schritte der QR-Transformation

> AA:=A;

> # For symbolic computation the low speed Gram-Schmidt process is

> # applied.

> for k from 1 to 40 do # 40 Iterationen

> R := QRdecomp(AA, Q=’q’, rank=’r’):

> AA:=R&*q:

> # print(evalf(evalm(R)));

> # print(evalf(evalm(q)));

> # print(evalf(evalm(AA)));

> od:

> R:=evalf(evalm(R));

> Q:=evalf(evalm(q));

> DD:=evalf(evalm(AA)); # Diagonalform

> x1:=DD[1,1];

> x2:=DD[2,2];

> x3:=DD[3,3];

> x4:=DD[4,4];

> x^2-x*(DD[2,2]+DD[3,3])+DD[2,2]*DD[3,3]-DD[2,3]^2;

> sol:=solve(x^2-x*(DD[2,2]+DD[3,3])+DD[2,2]*DD[3,3]-DD[2,3]^2,x);

> xx2:=sol[2];

> xx3:=sol[1];

> AA:=A; AA[1,1]:=1.0:

> # For matricies of floating point entries,

> # the high speed numerically stable

> # Householder transformations are used.



> AA:=R&*q:

> # print(evalf(evalm(R)));

> # print(evalf(evalm(q)));


> # print(evalf(evalm(AA)));

> od:




> x1:=DD[1,1];

> x2:=DD[2,2];

> x3:=DD[3,3];

> x4:=DD[4,4];

> x^2-x*(DD[2,2]+DD[3,3])+DD[2,2]*DD[3,3]-DD[2,3]^2;

> sol:=solve(x^2-x*(DD[2,2]+DD[3,3])+DD[2,2]*DD[3,3]-DD[2,3]^2,x);

> xx2:=sol[2];

> xx3:=sol[1];

2.Beispiel

Matrix und EW, EV

> n:=4:

> A := matrix(n,n,[[ 1,-1, 2, 2],

> [ 1, 1, 3, 4],

> [-2,-3, 1,-1],

> [-2,-4, 1, 1]]):

> det(A);

> vecs:=’vecs’:


> print(vecs);

> E:=diag(1,1,1,1):


QR-Transformation


> r;

> evalm(q); evalm(R &* q);



> AA:=A; AA[1,1]:=1.0:



> AA:=R&*q;

> od:




> DD:=evalf(evalm(AA)); # Blockdiagonalform

> x^2-x*(DD[1,1]+DD[2,2])+DD[1,1]*DD[2,2]-DD[1,2]*DD[2,1];

> sol12:=solve(x^2-x*(DD[1,1]+DD[2,2])+DD[1,1]*DD[2,2]

> -DD[1,2]*DD[2,1],x);

> x1:=sol12[1];

> x2:=sol12[2];

> x^2-x*(DD[3,3]+DD[4,4])+DD[3,3]*DD[4,4]-DD[3,4]*DD[4,3];

> sol34:=solve(x^2-x*(DD[3,3]+DD[4,4])+DD[3,3]*DD[4,4]

> -DD[3,4]*DD[4,3],x);

> x3:=sol34[1];

> x4:=sol34[2];

3.Beispiel

Matrix und EW, EV

> n:=4:

> A := matrix(n,n,[[ 2,-1, 0, 0],

> [-1, 2,-1, 0],

> [ 0,-1, 2,-1],

> [ 0, 0,-1, 2]]):

> det(A);

> vecs:=’vecs’:


> print(vecs);

> E:=diag(1,1,1,1):


QR-Transformation


> r;

> evalm(q);

> evalm(R &* q);



> AA:=A; AA[1,1]:=2.0:



> AA:=R&*q;

> od:





> x1:=DD[1,1];

> x2:=DD[2,2];

> x3:=DD[3,3];

> x4:=DD[4,4];

QR-Algorithmus als Zweistufen-Verfahren

Im Vorbereitungsschritt verwenden wir die Householder-Reflexion. Damit transfor-miert man die Matrix A = AT zunachst auf die Tridiagonalform.Im darauffolgenden Iterationsschritt wird die symmetrische Tridiagonalmatrix A′

durch die QR-Transformation auf Diagonalform gebracht.

Datei: nm4ip3.mws

Householder-Reflexion auf Tridiagonalform und QR-Algorithmus

> restart;

> with(linalg):

Matrix und EW, EV

> n:=4:

> A := matrix(n,n,[[1,-1,1,2],[-1,2,0,1],[1,0,-1,1],[2,1,1,0]]):

> det(A);

> vecs:=’vecs’:


> print(vecs);

> E:=diag(1,1,1,1):


Ueberfuehrung einer Matrix auf Tridiagonalform

mittels Householder-Reflexionen

1.Schritt

> y1:=submatrix(A,2..4,1..1);

> transpose(y1);

> y:=vector(3,[seq(y1[i,1],i=1..3)]);

> ny:=norm(y,2);

> if evalf(y[1])<0 then alpha:=ny else alpha:=-ny fi;

> e:=[1,0,0];

> v:=evalm(y-alpha*e);

> vn2:=norm(v,2)^2;

> v1:=matrix(3,1,v);

> dyad:= evalm(v1&*transpose(v1));

> Q1:=evalm(diag(1,1,1)-2/vn2*dyad); # Elementarmatrix


Kontrolle

> E1:=evalm(Q1 &* transpose(Q1)): # nicht vereinfacht

> E1:=simplify(evalm(Q1 &* transpose(Q1))); # numerisch gerechnet

> E1:=evalf(evalm(Q1 &* transpose(Q1))); # Einheitsmatrix

> evalf(E1[1,1]); # simplify hilft nicht

> evalf(E1[2,2]);

> evalf(E1[3,3]);

> row(Q1,1);

> seq(Q1[1,k],k=1..3);

> P1:=matrix(4,4,[[1,0,0,0],

> [0,seq(Q1[1,k],k=1..3)],

> [0,seq(Q1[2,k],k=1..3)],

> [0,seq(Q1[3,k],k=1..3)]]);

> As:=simplify(evalm(P1&*A));

> A1:=simplify(evalm(As&*transpose(P1)));

> A11:=matrix(4,4,(i,j) -> evalf(A1[i,j]));

2.Schritt

> y1:=evalf(submatrix(A1,3..4,2..2));

> transpose(y1);

> y:=vector(2,[seq(y1[i,1],i=1..2)]);

> ny:=simplify(norm(y,2));

> if evalf(y[1])<0 then alpha:=ny else alpha:=-ny fi;

> e:=[1,0];

> v:=evalm(y-alpha*e);

> vn2:=norm(v,2)^2;

> v1:=matrix(2,1,v);

> dyad:= evalm(v1&*transpose(v1));

> Q1:=evalm(diag(1,1)-2/vn2*dyad);

> E1:=evalm(Q1 &* transpose(Q1)): # nicht vereinfacht

> E1:=simplify(evalm(Q1 &* transpose(Q1))); # Einheitsmatrix

> evalf(E1[1,1]);

> evalf(E1[2,2]);

> row(Q1,1);

> seq(Q1[1,k],k=1..2);

> P2:=matrix(4,4,[[1,0,0,0],[0,1,0,0],

> [0,0,seq(Q1[1,k],k=1..2)],

> [0,0,seq(Q1[2,k],k=1..2)]]);

> As:=simplify(evalm(P2&*A1));


> A2:=simplify(evalm(As&*transpose(P2)));

> A21:=matrix(4,4,(i,j) -> evalf(A2[i,j])); # Tridiagonalform

Charakteristisches Polynom von Tridiagonalmatrix und EW

> AA:=A21;

> va:=vector(4,i->AA[i,i]);

> vb:=vector(3,i->AA[i+1,i]);

> vc:=vector(3,i->AA[i,i+1]);

3-Term-Rekursion

> ‘expand/pn‘ := proc(n,x) option remember;

> global va,vb,vc;

> if n = 0 then 1

> elif n = 1 then va[1]-x

> elif not type(n,integer) then pn(n,x) # can’t do anything

> else expand((va[n]-x)*pn(n-1,x) - vb[n-1]*vc[n-1]*pn(n-2,x))

> fi

> end:

> pn(4,x);

> pne:=expand(pn(4,x));

> f:=x->pne;

> solve(f(x),x);

QR-Algorithmus fuer Tridiagonalmatrix

> R := QRdecomp(AA, Q=’q’, rank=’r’);

> r;

> evalm(q);

> evalm(R &* q);

Mehrere Schritte des QR-Algorithmus

> AAA:=AA:


> R := QRdecomp(AAA, Q=’q’, rank=’r’):

> AAA:=R&*q;

> od:

> R:=evalm(R);

> Q:=evalm(q);

> DD:=evalm(AAA); # Diagonalform

> x1:=DD[1,1];

> x2:=DD[2,2];


> x3:=DD[3,3];

> x4:=DD[4,4];

EWP und SVD

Datei: nm4ip4.mws

SVD

> restart;

> with(linalg):

Matrix und EW, EV

> n:=4:

> A := matrix(n,n,[[1,-1,1,2],[-1,2,0,1],[1,0,-1,1],[2,1,1,0]]):

> det(A);

> vecs:=’vecs’:


> print(vecs);

> E:=diag(1,1,1,1):


> A2:=evalm(transpose(A) &* A);

> vecs1:=’vecs1’:

> lambda1 := evalf(Eigenvals(A2,vecs1));

> print(vecs1);

> sigma := [seq(sqrt(lambda1[i]),i=1..4)];

SVD

Beispiel A

> sv:=Svd(A,U,V);

> evalf(sv);

> evalm(U);

> evalm(V);

Beispiel B

> s:=0.01;

> B:=matrix(3,2,[[1,1],[s,0],[0,s]]);

> sv:=Svd(B,U,V);

> evalf(sv);

> evalm(U);

> evalm(V);


Beispiel C

> s:=100;

> C:=matrix(2,2,[[1,s],[0,1]]);

> sv:=Svd(C,U,V);

> evalf(sv);

> evalm(U);

> evalm(V);

C.4 Kap.6 - Polynome, Interpolation, Splines und

Differentiation

Lagrange-Interpolation, Basispolynome, Kondition der Interpolation

Datei: nm6ip1.mws

> restart:

> with(plots):

> with(plottools):












Lagrange-Interpolation, Referenz

> n := 3;

> xv := [-2, 1, 2, 4];

> yv := [ 3, 1,-3, 8];

Lagrange-Polynome, Basispolynome

> phi0 := x-> (x-xv[2])*(x-xv[3])*(x-xv[4])/

> ((xv[1]-xv[2])*(xv[1]-xv[3])*(xv[1]-xv[4]));

> simplify(phi0(x));

> phi1 := x-> (x-xv[1])*(x-xv[3])*(x-xv[4])/

> ((xv[2]-xv[1])*(xv[2]-xv[3])*(xv[2]-xv[4]));

C.4 Kap.6 - Polynome, Interpolation, Splines und Differentiation 17


> phi2 := x-> (x-xv[1])*(x-xv[2])*(x-xv[4])/

> ((xv[3]-xv[1])*(xv[3]-xv[2])*(xv[3]-xv[4]));


> phi3 := x-> (x-xv[1])*(x-xv[2])*(x-xv[3])/

> ((xv[4]-xv[1])*(xv[4]-xv[2])*(xv[4]-xv[3]));


> Q := plot(phi0,-2..4,title=‘phi0(x)‘,axes=normal):

> plots[display](Q);






> a:=array(1..2,1..2):

> a[1,1]:=plot(phi0,-2..4,title=‘phi0(x)‘,color=black):




> Q := display(a,scaling=constrained,xtickmarks=6,ytickmarks=3):







Lagrange-Interpolationspolynom

> L3 := x-> yv[1]*phi0(x)+yv[2]*phi1(x)+

> yv[3]*phi2(x)+yv[4]*phi3(x);

> simplify(L3(x));

> pl1 := plot(L3,-2..4,ytickmarks=8,title=‘Lagrange-IP L3(x)‘):

> punkte := [seq([xv[i],yv[i]],i=1..4)]:

> pl2 := polygon(punkte,style=point,symbol=circle):

> plots[display](pl1,pl2);




> plots[display](pl1,pl2);



Legesgue-Konstante, Kondition der Interpolation

> AbsL3 := x-> abs(phi0(x))+abs(phi1(x))+abs(phi2(x))+abs(phi3(x));

> simplify(AbsL3(x));

> seq([-0.73+i/100,AbsL3(-0.73+i/100)],i=-1..1);

> Kabs := 3.598070750;

> pl3 := plot([1,AbsL3],-2..4,0..4, title=‘Kondition, AbsL3(x)‘):

> pl4 := plot([[-0.73,0],[-0.73,3.6]]):

> punkte := [seq([xv[i],1],i=1..4),[-0.73,3.6]]:

> pl5 := polygon(punkte,style=point,symbol=circle):

> plots[display](pl3,pl4,pl5);




> plots[display](pl3,pl4,pl5);


----------------------------------------------------------------------

Datei: nm6ip2.mws

Prozedur zur Erzeugung des Interpolationspolynoms in verschiedenen

Darstellungen:

Newtonsche, Lagrangesche, baryzentrische Darstellung

> restart:

> interpol:=proc(stst::list,stw::list,var::name,typ::string)

> description ‘Polynominterpolation in verschiedenen Darstellungen‘;

> local i,k,n,omega,rho,ityp,x;

> n:=nops(stst);

> if nargs=3 then ityp:="Normal" else ityp:=typ; fi;

> if ityp="Lagrange" then

> omega:=[1];

> for k from 1 to n-1 do

> for i from 1 to nops(omega) do

> omega:=subsop(i=omega[i]/(stst[i]-stst[k+1]),omega);

> od;

> omega:=[op(omega),-sum(omega[j],j=1..nops(omega))];

> od;

> i:=’i’: k:=’k’:

> [sum(omega[i]/(var-stst[i])*stw[i],i=1..n)/

> sum(omega[i]/(var-stst[i]),i=1..n),

> sum(stw[i]*omega[i]*product(var-stst[k],k=1..i-1)*

> product(var-stst[k],k=i+1..n),i=1..n)];

> elif


> ityp="Newton" then

> omega:=stw;

> for k from 0 to n-1 do rho:=stw[k+1];

> for i from 0 to k-1 do

> rho:=(rho-omega[i+1])/(stst[k+1]-stst[i+1]);

> od;

> omega:=subsop(k+1=rho,omega);

> od;

> i:=’i’: k:=’k’:

> sum(omega[k]*product(var-stst[i],i=1..k-1),k=1..n);

> else

> interp(stst,stw,var);

> fi;

> end:

Aufruf:

Anzahl der Parameter: 3 oder 4

Bedeutung:

1. Parameter: Stuetzstellen (Liste)

2. Parameter: Stuetzwerte (Liste)

3. Parameter: Name der zu verwendenden Variablen

4. Parameter: Newton oder Lagrange; wenn dieser Parameter fehlt, wird

Maples interne Interpolationsroutine interp(stst,stw,var) verwendet.

Besonderheiten:

Das Lagrangesche Interpolationspolynom kann auf zwei verschiedene

Arten ausgegeben werden; dies wird durch einen zusaetzlichen

Index [1] bzw. [2] erreicht.

Beispiel:

Referenz

> n := 3;

> xv := [1, 2, 5, 6];

> yv := [2, 4, 1, 1];

> interpol(xv,yv,x,"Newton");

> N3 := 2+2*(x-1)-3/4*(x-1)*(x-2)+1/5*(x-1)*(x-2)*(x-5);

> interpol(xv,yv,x,"Lagrange")[2]; # die konventionelle Darstellung

> interpol(xv,yv,x,"Lagrange")[1]; # die baryzentrische Darstellung

> interpol(xv,yv,x);

> interp(xv,yv,x); # Standardfunktion


Datei: nm6ip3.mws

Kubische Hermite-Basis

> restart:

> with(plots):

> with(plottools):








Kubische Hermite-Basis

Referenz

> n := 3;

> xv := [0, 0, 1, 1];

> yv0 := [1, 0, 0, 0];

> yv1 := [0, 1, 0, 0];

> yv2 := [0, 0, 1, 0];

> yv3 := [0, 0, 0, 1];

> d := [0, 1, 0, 1];

Basispolynome

> H30 := x-> 2*x^3-3*x^2+1;

> H31 := x-> x^3-2*x^2+x;

> H32 := x-> -2*x^3+3*x^2;

> H33 := x-> x^3-x^2;

> Q := plot(H30,-1..2,title=‘Hermite-Basispolynom H30(x)‘,

> axes=normal,ytickmarks=6):







> pl0:=plot(H30,0..1,color=black):





> pl :=plot([[1,0],[1,1]]):

> t0 := textplot([0.25,0.7,‘H30(x)‘]):

> t1 := textplot([0.5,0.17,‘H31(x)‘]):

> t2 := textplot([0.75,0.7,‘H32(x)‘]):

> t3 := textplot([0.4,-0.15,‘H33(x)‘]):

> Q:=display([pl0,pl1,pl2,pl3,pl,t0,t1,t2,t3],

> scaling=constrained,xtickmarks=6,ytickmarks=7,

> titlefont=[TIMES,BOLD,12],

> title=‘Kubische Hermite-Basis H3i(x) auf [0,1]‘):







-------------------------------------------------------------------

Datei: nm6ip4.mws

Rungesche Effekt bei der Interpolation der nichtglatten Funktion

f(x)=|x|, -1<=x<=1, mit aequidistanten Stuetzstellen

> restart:

> with(plots):

> with(plottools):








Referenz

> n := 2;

> xv := [-1, 0, 1];

> yv := [ 1, 0, 1];

> f := x-> abs(x);

> interp(xv,yv,x);


Interpolationspolynome vom Grade 2,4,8,10

> p2 := x->x^2;

> p4 := x->-4/3*x^4+7/3*x^2;

> p8 := x->-1024/63*x^8+1408/45*x^6-172/9*x^4+533/105*x^2;

> p10 := x->390625/5184*x^10-1015625/6048*x^8+

> 221875/1728*x^6-13375/324*x^4+1627/252*x^2;

> Q:=plot([p8,f],-1..1,0..1.5,scaling=constrained,

> xtickmarks=4,ytickmarks=4,

> title=‘f(x)=|x| und p8(x)‘,color=black):







> a:=array(1..2,1..2):

> a[1,1]:=plot([ p2,f],-1..1,0..1.5, title=‘p2(x)‘,color=black):



> a[2,2]:=plot([p10,f],-1..1,0..1.5, title=‘p10(x)‘,color=black):

> Q := display(a,scaling=unconstrained,xtickmarks=2,ytickmarks=2):







---------------------------------------------------------------------

Datei: nm6ip5.mws

Knotenpunktpolynome mit aequidistanten und Tschebyscheff-Knoten im

Vergleich

> restart:

> with(plots):

> with(plottools):









1. Referenz

> n1 := 4;

> xva1 := [seq(-1+2*k/n1,k=0..n1)];

> xvn1 := [seq(-cos((2*k+1)/(2*n1+2)*Pi),k=0..n1)];

> evalf(xvn1);

> oma1 := x-> product(x-xva1[k],k=1..n1+1);

> evalf(oma1(x));

> oma1(1);

> omn1 := x-> product(x-xvn1[k],k=1..n1+1);

> evalf(omn1(x));

> omn1(1);

> evalf(2^n1*omn1(1));

> evalf(2^n1*omn1(-1));

2.Referenz

> n2 := 8;

> xva2 := [seq(-1+2*k/n2,k=0..n2)];

> xvn2 := [seq(-cos((2*k+1)/(2*n2+2)*Pi),k=0..n2)];

> evalf(xvn2);

> oma2 := x-> product(x-xva2[k],k=1..n2+1);

> evalf(oma2(x));

> oma2(1);

> omn2 := x-> product(x-xvn2[k],k=1..n2+1);

> evalf(omn2(x));

> omn2(1);

> evalf(2^n2*omn2(1));

> evalf(2^n2*omn2(-1));

Plot mit aequidistanten Stuetzstellen

> plot(oma1,-1..1,title=‘omega_(5)(x), xi(0..4) aequid.‘,color=black);

> plot(oma2,-1..1,title=‘omega_(9)(x), xi(0..8) aequid.‘,color=black);

> a:=array(1..1,1..2):

> a[1,1]:=plot(oma1,-1..1,

> title=‘omega_(5)(x), xi(0..4)‘,color=black):

> a[1,2]:=plot(oma2,-1..1,

> title=‘omega_(9)(x), xi(0..8) aequid.‘,color=black):









Plot mit Tschebyscheff-Stuetzstellen

> plot(omn1,-1..1,

> title=‘omega_(5)(x), xi(0..4) Tschebyscheff‘,color=black);

> plot(omn2,-1..1,

> title=‘omega_(9)(x), xi(0..8) Tschebyscheff‘,color=black);

> a:=array(1..1,1..2):

> a[1,1]:=plot(omn1,-1..1,

> title=‘omega_(5)(x), xi(0..4)‘,color=black):

> a[1,2]:=plot(omn2,-1..1,

> title=‘omega_(9)(x), xi(0..8) Tscheb.‘,color=black):








---------------------------------------------------------------------

Datei: nm6ip6.mws

Trigonometrische Interpolation mit aequidistanten Stuetzstellen (DFT)

und Fourier-Reihenentwicklung (Fourier-Polynome, Approximation im

quadratischen Mittel) fuer Signalfunktion f(x) mit Grafik

> restart:

> with(plots):

> with(plottools):

















> read ‘d:/neundorf/nwptexte/math93/cfourier.m‘;

> a:=-Pi; b:=Pi; T:=b-a; N:=8;

> u1:=x->piecewise(x=-Pi,0,x<0,-1,x>0,1,0);

> # smartplot

> u1(x);

> smartplot(piecewise(x<0,-1,x>0,1,0));

> readlib(discont):

> discont(u1(x),x);

> plot(u1(x),x=a-1..b+1,-1..1,thickness=3,color=red);

> u2:=x->if x<0 then -1 elif x>0 then 1 else evalf(1/2) fi;

> u2(x);

> u2(0.5);

> u3:=x->piecewise(x<a-T/2,-1,x<a,1,x<0,-1,x<b,1,x<b+T/2,-1,1);

> u3(x);

> plot(u3(x),x=-8..8,y=-1..1,thickness=2,title=‘u3(x)=sign(sin(x))‘);

> f:=x->u1(x-T*floor((x-a)/T));

> f(x);

> Q1:=plot([f(x),sin(x)],x=-8..8,-1..1,thickness=2,

> title=‘f(x)=sign(sin(x))‘):

> Q2:=plot(f(x),x=-8..8,-1.5..1.5,thickness=1):

> plots[display](Q1);






> xp:=[seq(k*T/N,k=0..N)];

> yp:=[seq(f(k*T/N),k=0..N)];

> ref:=[seq([xp[k],yp[k]],k=1..N+1)];


> ref0:=[seq([xp[k],0],k=1..N+1)];

> Q3:=plot(ref,style=point,symbol=circle):

> Q30:=plot(ref0,style=point,symbol=circle):

> PhiN:= x -> (1+sqrt(2))/2*sin(x)+(-1+sqrt(2))/2*sin(3*x);

> Q:=plot(PhiN(x),x=-8..8,-1.5..1.5,thickness=1,

> title=‘ f(x)=sign(sin(x)),

Phi8(x)=(1+sqrt(2))/2*sin(x)+(-1+sqrt(2))/2*sin(3*x)‘):

> plots[display]([Q,Q2,Q3]);




> plots[display]([Q,Q2,Q3]);


Fourier-Polynom

Approximation im quadratischen Mittel

> cfourier(u1,a..b,N,‘reell‘,‘Plot‘);

> bk:= k -> 2*(1-(-1)^k)/(Pi*k);

> bk(1); bk(2); bk(k);

Fourier-Polynom, explizit

> n:=’n’:

> fs:=(x,n)-> sum(bk(k)*sin(k*x),k=1..n);

> fs(x,n);

> fs(x,4);

> Q:=plot(fs(x,4),x=-8..8,-1.5..1.5,thickness=2,

> title=‘f(x)=sign(sin(x)), 0 fs(x,4)=4/Pi*sin(x)+4/(3Pi)*sin(3*x)‘):

> plots[display]([Q,Q2]);






> P:=array(1..2,1..2,[]):

> n:=2:

> for i from 1 by 1 to 2 do

> for j from 1 by 1 to 2 do

> n:=n+2:

> if i*j=1 then

> P[i,j]:=plot([f(x),fs(x,n)],x=-1..T+1,color=black,

> title=‘f(x) und Fourier-Polynome, n=4,6,8,10‘)


> else

> P[i,j]:=plot([f(x),fs(x,n)],x=-1..T+1,color=black)

> fi:

> od:

> od:

> plots[display](P);






> Q:=plot([f(x),PhiN(x),fs(x,4)],x=-1..T+1,color=black,

> title=‘f(x)=sign(sin(x)), Phi8(x), fs(x,4)‘):







> Q:=plot((PhiN(x)-fs(x,4)),x=-1..T+1,color=black,

> title=‘Fehler Phi8(x)-fs(x,4)‘):







---------------------------------------------------------------------

Datei: nm6ip7.mws

Kubischer Spline

> restart:

> with(plots):

> with(plottools):







Referenz

> n:=2;

> xk:=[0, 1/2, 1];

> yk:=[1, -1/2, 2];

> s:=x->piecewise(x<xk[1],1-5*x, x<xk[2],1-5*x+8*x^3,x<xk[3],

> -1/2+(x-xk[2])+12*(x-xk[2])^2-8*(x-xk[2])^3, 2+7*(x-xk[3]));

> # smartplot

> s(x);

> smartplot(piecewise(x<xk[1],1-5*x,x<xk[2],1-5*x+8*x^3,x<xk[3],

> -1/2+(x-xk[2])+12*(x-xk[2])^2-8*(x-xk[2])^3,2+7*(x-xk[3])));

> plot(s(x),x=xk[1]-0.5..xk[3]+0.5,thickness=1,color=red);

> si1:=seq(s(i/50),i=0..50);

> evalf(si1);

> s(0.216); s(0.217);

> s(0.455); s(0.456); s(0.457);

> s(0.675); s(0.676);

> si2:=seq(s(i/4),i=0..4);

> evalf(si2);

> ref:=[seq([xk[i],yk[i]],i=1..n+1)];

> ref0:=[[0.216,0],[0.456,0],[0.675,0],[0.456,-0.521]];

> Qt:=textplot([[0.2,-0.1,‘xs1‘],[0.45,-0.1,‘xm‘],

> [0.7,-0.1,‘xs2‘]],color=black):

> Q2:=plot(ref,style=point,symbol=circle):

> Q3:=plot([[0.5,-0.5],[0.5,0],[1,0],[1,2]]):

> Q4:=plot(ref0,style=point,symbol=cross):

> Q1:=plot(s(x),x=xk[1]-0.2..xk[3]+0.2,thickness=2,xtickmarks=3,

> color=red,title=‘Kubischer Spline s(x)‘):

> plots[display]([Q1,Q2,Q3,Q4,Qt]);




> plots[display]([Q1,Q2,Q3,Q4,Qt]);



Datei: nm6ip8.mws

Basis-Splines (B-Splines) der Ordnung k=2,3,4

Berechnung und Grafik

> restart:

> with(plots):

> with(plottools):

> readlib(bspline): readlib(spline):










The functions bspline(d,v) or bspline(d,v,k) compute the segment

polynomials for the B-spline of degree d in the symbol v

on the knot sequence k.

If k is not specified, the uniform knot sequence [0,1,...,d+1] is used.

B-Spline der Ordnung k=2 (Grad k-1=1), "Huetchen"

Unterteilung {0,1,2,3,4}, n=5

> bspline(1,x,[0,0,1]);

> p0:=plot(bspline(1,x,[0,0,1]),x=-1..5,0..1,thickness=2):

> bspline(1,x,[0,1,2]);


> bspline(1,x,[1,2,3]);


> bspline(1,x,[2,3,4]);


> bspline(1,x,[3,4,4]);


> plots[display]([p0,p1,p2,p3,p4],

> title=‘B-Splines N(i,2)(x), i=0,1,2,3,4‘);





> plots[display]([p0,p1,p2,p3,p4],

> title=‘B-Splines N(i,2)(x), i=0,1,2,3,4‘);


B-Spline der Ordnung k=3 (Grad k-1=2), "quadratische Parabel"

Unterteilung {0,1,2,3,4}

> bspline(2,x,[0,0,0,1]);

> pm1:=plot(bspline(2,x,[0,0,0,1]),x=-1..5,0..1,thickness=2):

> bspline(2,x,[0,0,1,2]);

> p0:=plot(bspline(2,x,[0,0,1,2]),x=-1..5,0..1,thickness=2):

> bspline(2,x,[0,1,2,3]);


> bspline(2,x,[1,2,3,4]);


> bspline(2,x,[2,3,4,4]);


> bspline(2,x,[3,4,4,4]);


> plots[display]([pm1,p0,p1,p2,p3,p4],

> title=‘B-Splines N(i,3)(x), i=-1,0,1,2,3,4‘);




> plots[display]([pm1,p0,p1,p2,p3,p4],

> title=‘B-Splines N(i,3)(x), i=-1,0,1,2,3,4‘);


B-Spline der Ordnung k=4 (Grad k-1=3), "kubische Parabel"

Unterteilung {0,1,2,3,4}, n=5

> bspline(3,x,[0,0,0,0,1]);

> pm2:=plot(bspline(3,x,[0,0,0,0,1]),x=-1..5,0..1,thickness=2):

> bspline(3,x,[0,0,0,1,2]);

> pm1:=plot(bspline(3,x,[0,0,0,1,2]),x=-1..5,0..1,thickness=2):

C.5 Kap.7 - Orthogonale Funktionensysteme und Termrekursion 31

> bspline(3,x,[0,0,1,2,3]);

> p0:=plot(bspline(3,x,[0,0,1,2,3]),x=-1..5,0..1,thickness=2):

> bspline(3,x,[0,1,2,3,4]);


> bspline(3,x,[1,2,3,4,4]);


> bspline(3,x,[2,3,4,4,4]);


> bspline(3,x,[3,4,4,4,4]);


> plots[display]([pm2,pm1,p0,p1,p2,p3,p4],

> title=‘B-Splines N(i,4)(x), i=-2,-1,0,1,2,3,4‘);




> plots[display]([pm2,pm1,p0,p1,p2,p3,p4],

> title=‘B-Splines N(i,3)(x), i=-2,-1,0,1,2,3,4‘);


C.5 Kap.7 - Orthogonale Funktionensysteme und

Termrekursion

Datei: nm7ip1.mws

Orthogonale Polynome

> restart:

> with(plots):

> with(plottools):

> with(orthopoly); # orthopoly package

G(n, a, x) generates the nth Gegenbauer polynomial.

H(n, x) generates the nth Hermite polynomial.

L(n, x) generates the nth Laguerre polynomial.

L(n, a, x) generates the nth generalized Laguerre polynomial.

P(n, x) generates the nth Legendre polynomial.


P(n, a, b, x) generates the nth Jacobi polynomial.

T(n, x) generates the nth Chebyshev polynomial of the first kind.

U(n, x) generates the nth Chebyshev polynomial of the second kind.












Suppose we want to manipulate symbolically the Chebyshev polynomials

of the first kind Tn(x). We can represent these in Maple as T(n,x).

Recall that Tn(x) satisfies the linear recurrence T0(x)=1, T1(x)=x,

and Tn(x) = 2 x T{n-1}(x) - T{n-2}(x).

> T(2,x); # Chebyshev polynomials

Suppose also that for a particular value of n we want to expand

T(n,x) out as a polynomial in x. We can tell Maple’s expand function

how to do this by writing the own routine ‘expand/TT‘.

When expand sees T(n,x), it will invoke ‘expand/TT‘(n,x).

Hence we can write the following.

> ‘expand/TT‘ := proc(n,x) option remember;

> if n = 0 then 1

> elif n = 1 then x

> elif not type(n,integer) then TT(n,x)

> # can’t do anything

> else expand(2*x*TT(n-1,x) - TT(n-2,x))

> fi

> end:

This routine is recursive, but because we used the remember option,

the routine will compute T(100,x) quite quickly.

> whattype(TT(4,x));

> TT(4.0,x);

> TT(4,x);

> expand(TT(4,x));

C.5 Kap.7 - Orthogonale Funktionensysteme und Termrekursion 33

> expand(TT(25,x)); # not sorted

> expand(TT(24,x)); # polynomial sorted up to degree 24

> sort(expand(TT(30,x))); # use sort

> p := sort(expand(TT(100,x))): # no display

> coeff(p,x,0);

> coeff(p,x,100);

Legendre-Polynome

> for n from 0 to 5 do

> P(n,x);

> od;


> p[n]:=plot(P(n,x),x=-1..1):

> od:

> plots[display]([seq(p[n],n=0..5)],

> title=‘Legendre-Polynome P(n,x), n=0..5‘);





> title=‘Legendre-Polynome P(n,x), n=0..5‘);


Tschebyscheff-Polynome


> T(n,x);

> od;


> p[n]:=plot(T(n,x),x=-1..1):

> od:


> title=‘Tschebyscheff-Polynome T(n,x), n=0..5‘);





> title=‘Tschebyscheff-Polynome T(n,x), n=0..5‘);



Hermite-Polynome


> H(n,x);

> od;


> p[n]:=plot(H(n,x),x=-2.1..2.1):

> od:


> title=‘Hermite-Polynome H(n,x), n=0..5‘);





> title=‘Hermite-Polynome H(n,x), n=0..5‘);


Laguerre-Polynome


> L(n,x);

> od;


> p[n]:=plot(L(n,x),x=0..12):

> od:


> title=‘Laguerre-Polynome L(n,x), n=0..5‘);





> title=‘Laguerre-Polynome L(n,x), n=0..5‘);


C.6 Kap.8 - Approximation, Ausgleichsrechnung und Fourier-Reihen 35

C.6 Kap.8 - Approximation, Ausgleichsrechnung

und Fourier-Reihen

Datei: nm8ip1.mws

Approximation - Uebersicht

> restart:

> with(plots):

> with(plottools):




















Interpolation

Beispiel 1

> n := 4;

> xv := [-1,-0.5,0,0.5,1];

> yv := [seq(exp(xv[i]),i=1..n+1)];

> f := x->exp(x);

> N4 := x->0.043435*x^4+0.177348*x^3+0.499645*x^2+0.997853*x+1;

> p0:=plot([seq([xv[i],yv[i]],i=1..n+1)],style=point):

> p1:=plot(f(x),x=-1..1,thickness=2):

> p2:=plot(N4(x),x=-1..1):


> plots[display]([p0,p1,p2],

> title=‘Polynominterpolation fuer f(x)=exp(x), Ref.,N4(x)‘);





> title=‘Polynominterpolation fuer f(x)=exp(x), Ref.,N4(x)‘);


> p3:=plot(f(x)-N4(x),x=-1..1,thickness=2):

> plots[display]([p3],title=‘Interpolationsfehler f(x)-N4(x)‘);




> plots[display]([p3],title=‘Interpolationsfehler f(x)-N4(x)‘);


Beispiel 2

> n := 4;

> xv := [0,1/4,1/2,3/4,1];

> yv := [seq(sin(Pi*xv[i]),i=1..n+1)];

> f := x->sin(Pi*x);

> interp(xv,yv,x);

> p4:=x->interp(xv,yv,x):

> p4(x);

> evalf(p4(x));


> p1:=plot(f(x),x=0..1,thickness=2):

> p2:=plot(p4(x),x=0..1):


> title=‘Polynominterpolation fuer f(x)=sin(Pi*x), Ref.,p4(x)‘);





> title=‘Polynominterpolation fuer f(x)=sin(Pi*x), Ref.,p4(x)‘);


> p3:=plot(f(x)-p4(x),x=0..1,thickness=2):

> plots[display]([p3],title=‘Interpolationsfehler f(x)-p4(x)‘);





> plots[display]([p3],title=‘Interpolationsfehler f(x)-p4(x)‘);


Funktionenreihen: Taylor, Maclaurin

Beispiel

> M4 := x->0.041667*x^4+0.166667*x^3+0.5*x^2+x+1;


> p1:=plot(f(x),x=-1..1,thickness=2):

> p2:=plot(M4(x),x=-1..1):


> title=‘Taylor-Reihe: Ref.,f(x)=exp(x), M4(x)‘);





> title=‘Taylor-Reihe: Ref.,f(x)=exp(x), M4(x)‘);


> p3:=plot(f(x)-M4(x),x=-1..1,thickness=2):

> plots[display]([p3],title=‘Fehler f(x)-M4(x)‘);




> plots[display]([p3],title=‘Fehler f(x)-M4(x)‘);


Konvergenzbereich

Beispiel 1

> f := x->1/(1+x^2);

> phi0 := x->1;

> phi2 := x->1-x^2;

> phi4 := x->1-x^2+x^4;

> p0:=plot(phi0(x),x=0..2):

> pf:=plot(f(x),x=0..3,thickness=2):

> p2:=plot(phi2(x),x=0..1.2):

> p4:=plot(phi4(x),x=0..1.2):

> p1:=plot([[1,-0.1],[1,1.1]]):

> t0 := textplot([[2.1,1,‘phi0(x)‘],[1.3,-0.3,‘phi2(x)‘],


> [1.25,1.3,‘phi4(x)‘],[2.5,0.2,‘f(x)=1/(1+x^2)‘]]):

> plots[display]([p0,p1,p2,p4,pf,t0],

> title=‘Taylor-Reihe fuer f(x): phi0(x),phi2(x),phi4(x)‘);




> plots[display]([p0,p1,p2,p4,pf,t0],

> title=‘Taylor-Reihe fuer f(x): phi0(x),phi2(x),phi4(x)‘);


Beispiel 2

> f := x->piecewise(x=0,0,exp(-1/x^2)); # auch einfach exp(-1/x^2)

> f(x);

> p0 := plot(f(x),x=-3..3,thickness=2):

> plots[display]([p0],title=‘f(x)=exp(-1/x^2)‘);




> plots[display]([p0],title=‘f(x)=exp(-1/x^2)‘);


----------------------------------------------------------------------

Datei: nm8ip2.mws

Approximation von f(x)=ln(1+x), -0.5<=x<=0.5

> restart:

> with(plots):

> with(plottools):













Interpolation

> n := 1;

> xv := [-0.5,0.5];

> yv := [seq(ln(1+xv[i]),i=1..n+1)];

> f := x->ln(1+x);

> f1:= x->x;

> f2:= x->x-x^2/2;

> evalf(f2(-0.5));

> evalf(f2(0.5));

> p1:= x->-(ln(2)-0.5*ln(3))+ln(3)*x;

> evalf(p1(0));

> q1:= x->-0.5*(ln(2)-0.5*ln(3))+ln(3)*x;

> evalf(q1(-0.5));

> evalf(q1(0.5));

> d:=evalf(0.5*(ln(2)-0.5*ln(3)));

> xd:=-0.05;

> dd:=evalf(f(xd)-q1(xd));

> xm:=evalf(1/ln(3)-1);

> dm:=evalf(f(xm)-q1(xm));

> pl0:=plot([seq([xv[i],yv[i]],i=1..n+1)],style=point):

> pl1:=plot(f(x),x=-0.5..0.5,thickness=3,xtickmarks=6,color=black):

> pl2:=plot(f1(x),x=-0.5..0.5):

> pl3:=plot(f2(x),x=-0.5..0.5):

> pl4:=plot(p1(x),x=-0.5..0.5):

> pl5:=plot(q1(x),x=-0.5..0.5,thickness=2):

> pl6:=plot({[[0,p1(0)],[0,q1(0)]],[[-0.5,p1(-0.5)],[-0.5,q1(-0.5)]],

> [[0.5,p1(0.5)],[0.5,q1(0.5)]]},thickness=4,color=black):

> pl7:=textplot([[0.11,0.08,‘f(x)‘],[0.46,0.5,‘f1(x)‘],

> [0.49,0.34,‘f2(x)‘],[0.35,0.2,‘p1(x)‘],

> [0.25,0.17,‘q1(x)‘]]):

> plots[display]([pl0,pl1,pl2,pl3,pl4,pl5,pl6,pl7],

> title=‘Approximationen fuer f(x)=ln(1+x)‘);




> plots[display]([pl0,pl1,pl2,pl3,pl4,pl5,pl6,pl7],

> title=‘Approximationen fuer f(x)=ln(1+x)‘);


> pl8:=plot(f(x)-q1(x),x=-0.5..0.5,thickness=2,xtickmarks=6):

> pl9:=plot({[[0,0],[0,f(0)-q1(0)]],[[-0.5,0],[-0.5,f(-0.5)-q1(-0.5)]],


> [[0.5,0],[0.5,f(0.5)-q1(0.5)]],[[xm,0],[xm,dm]]},

> x=-0.5..0.5,thickness=3,color=black):

> d:=’d’:

> pl10:=textplot([[0.049,0.074,‘d=0.0719‘],[-0.15,0.035,‘dm=0.0764‘],

> [-0.485,-0.03,‘d‘],[ 0.485,-0.03,‘d‘]]):

> plots[display]([pl8,pl9,pl10],

> title=‘Approximationsfehler f(x)-q1(x)‘);





> title=‘Approximationsfehler f(x)-q1(x)‘);


> r1:= x->p1(x)+0.5*(f(xm)-p1(xm));

> evalf(r1(-0.5)); evalf(r1(xm));

> evalf(r1(0.5));

> evalf(f(-0.5)-r1(-0.5));

> dopt:=evalf(f(xm)-r1(xm));

> evalf(f(0.5)-r1(0.5));

> pl12:=plot(r1(x),x=-0.5..0.5,thickness=2):

> pl13:=plot(r1(x)+dopt,x=-0.5..0.5):

> pl14:=plot({[[xm,f(xm)],[xm,r1(xm)]],[[-0.5,f(-0.5)],

> [-0.5,r1(-0.5)]],[[0.5,f(0.5)],[0.5,r1(0.5)]]},

> thickness=4,color=black):

> pl15:=textplot([[0.11,0.08,‘f(x)‘],[0.35,0.2,‘p1(x)‘],

> [0.25,0.17,‘r1(x)‘]]):

> plots[display]([pl0,pl1,pl4,pl12,pl13,pl14,pl15],

> title=‘Beste Approximation r1(x) fuer f(x)=ln(1+x)‘);




> plots[display]([pl0,pl1,pl4,pl12,pl13,pl14,pl15],

> title=‘Beste Approximation r1(x) fuer f(x)=ln(1+x)‘);


> pl16:=plot(f(x)-r1(x),x=-0.5..0.5,thickness=2,xtickmarks=6):

> pl17:=plot({[[xm,0],[xm,f(xm)-r1(xm)]],

> [[-0.5,0],[-0.5,f(-0.5)-r1(-0.5)]],

> [[0.5,0],[0.5,f(0.5)-r1(0.5)]]},

> x=-0.5..0.5,thickness=3,color=black):


> dopt:=’dopt’:

> pl18:=textplot([[-0.15,0.078,‘dopt=0.0742‘],

> [-0.475,-0.03,‘dopt‘],[ 0.475,-0.03,‘dopt‘]]):


> title=‘Approximationsfehler f(x)-r1(x)‘);





> title=‘Approximationsfehler f(x)-r1(x)‘);


Tschebyscheff-Alternante

> altern:=[-0.5,xm,0.5];

--------------------------------------------------------------------

Datei: nm8ip3.mws

Gleichmaessige Approximation von f(x)=x^6, -1<=x<=1,

auf diskreter Menge xk=cos(k*pi/3), k=0,1,2,3

> restart:

> with(plots): with(plottools):








> n := 2;

> xv := [seq(cos(k*Pi/(n+1)),k=0..n+1)];

> yv := [seq(xv[i]^6,i=1..n+2)];

> f := x->x^6;

> p2:= x->-5/16+21/16*x^2;

> xx:=sqrt(sqrt(7))/2;

> xy:=evalf(xx);

> f(xx)-p2(xx);

> evalf(f(xy)-p2(xy));

> pl0:=plot([seq([xv[i],yv[i]],i=1..n+1)],style=point):

> pl1:=plot(f(x),x=-1..1,thickness=3,xtickmarks=4):


> pl2:=plot(p2(x),x=-1..1):

> pl5:=plot({[[0,0],[0,p2(0)]],[[-xx,p2(-xx)],[-xx,xx^6]],

> [[xx,p2(xx)],[xx,xx^6]]},thickness=4,color=black):

> pl6:=plot({[[xx,-0.02],[xx,xx^6]],[[-xx,-0.02],[-xx,xx^6]]},

> thickness=1,color=black):

> pl7:=textplot([[0.25,0.05,‘x^6‘],[0.65,0.45,‘p2(x)‘],

> [xy,-0.05,‘0.8133‘],[-xy,-0.05,‘-0.8133‘] ]):

> plots[display]([pl0,pl1,pl2,pl5,pl6,pl7],

> title=‘Approximation fuer f(x)=x^6 auf xk=cos(k*pi/3),k=0,1,2,3‘);




> plots[display]([pl0,pl1,pl2,pl5,pl6,pl7],

> title=‘Approximation fuer f(x)=x^6 auf xk=cos(k*pi/3),k=0,1,2,3‘);


> q2:= x->-5/32+15/16*x^2;

> x1:=sqrt(sqrt(5))/2;

> x2:=evalf(x1);

> f(x1)-q2(x1);

> evalf(f(x1)-q2(x1));

> pl8:=plot(q2(x),x=-1..1):

> pl9:=plot({[[0,0],[0,q2(0)]],[[x2,q2(x2)],[x2,x2^6]],

> [[1,q2(1)],[1,1]],[[-x2,q2(-x2)],[-x2,x2^6]],

> [[-1,q2(-1)],[-1,1]]}, thickness=3,color=black):

> pl10:=textplot([[0.25,0.05,‘x^6‘],[0.7,0.45,‘q2(x)‘],

> [x2,-0.05,‘0.7477‘]]):

> pl11:=plot({[[x2,-0.02],[x2,x2^6]]},thickness=1,color=black):

> plots[display]([pl1,pl8,pl9,pl10,pl11],

> title=‘Approximation q2(x) fuer f(x)=x^6‘);




> plots[display]([pl1,pl8,pl9,pl10,pl11],

> title=‘Approximation q2(x) fuer f(x)=x^6‘);


Tschebyscheff-Alternante naeherungsweise

> altern:=[-x2,0,x2,1];

> fa:=[seq(f(altern[i])-q2(altern[i]),i=1..4)];

> evalf(fa);


Datei: nm8ip4.mws

Gleichmaessige Approximation von f(x)=sqrt(x), 1/16<=x<=1,

Remez-Algorithmus, xk, k =0,1,2,3

> restart:

> with(plots):

> with(plottools):

> with(linalg):








> n := 2;

> xv := [1/16,2/5,4/5,1];

> yv := [seq(sqrt(xv[i]),i=1..n+2)];

> f := x->sqrt(x);

> p2:= x->a0*x^2+a1*x+a2;

> p2m:= x->a0m*x^2+a1m*x+a2m;

Remez-Algorithmus

> A := matrix(4,4):

> a := vector(4):

> b := vector(4):

> x0:=xv[1]: x1:=xv[2]: x2:=xv[3]: x3:=xv[4]:

> iter:=5:

> printf(‘j=%2.0f\n‘,0);

> printf(‘x1=%12.9f ‘,x1);

> printf(‘x2=%12.9f\n‘,x2);

> for j from 1 to iter do

> A := [[x0^2,x0,1,1],

> [x1^2,x1,1,-1],

> [x2^2,x2,1,1],

> [x3^2,x3,1,-1]];

> b := [sqrt(x0),sqrt(x1),sqrt(x2),sqrt(x3)];

> inva:=evalm(inverse(A));

> a:=inva &* b;


> a:=evalm(a);

> det(A);

> a0:=evalf(a[1]);

> a1:=evalf(a[2]);

> a2:=evalf(a[3]);

> e:=evalf(a[4]);

> printf(‘j=%2.0f\n‘,j);

> printf(‘a0=%12.9f ‘,a0);

> printf(‘a1=%12.9f ‘,a1);

> printf(‘a2=%12.9f ‘,a2);

> printf(‘e =%12.9f\n‘,e);

> z:=solve(1/(2*sqrt(x))-(2*a0*x+a1),x):

> x1:=z[1];

> x2:=z[2];

> if x1>x2 then h:=x1; x1:=x2; x2:= h; fi;

> printf(‘x1=%12.9f ‘,x1);

> printf(‘x2=%12.9f\n‘,x2);

> od:

Modifizierter Remez-Algorithmus

> x0m:=xv[1]: x1m:=xv[2]: x2m:=xv[3]: x3m:=xv[4]:

> iter:=5:

> printf(‘j=%2.0f\n‘,0);

> printf(‘x1=%12.9f ‘,x1m);

> printf(‘x2=%12.9f\n‘,x2m);

> for j from 1 to iter do

> A := [[x0m^2,x0m,1,sqrt(x0m)],

> [x1m^2,x1m,1,-sqrt(x1m)],

> [x2m^2,x2m,1,sqrt(x2m)],

> [x3m^2,x3m,1,-sqrt(x3m)]];

> b := [sqrt(x0m),sqrt(x1m),sqrt(x2m),sqrt(x3m)];

> inva:=evalm(inverse(A));

> a:=inva &* b;

> a:=evalm(a);

> det(A);

> a0m:=evalf(a[1]);

> a1m:=evalf(a[2]);

> a2m:=evalf(a[3]);

> em:=evalf(a[4]);


> printf(‘j=%2.0f\n‘,j);

> printf(‘a0=%12.9f ‘,a0m);

> printf(‘a1=%12.9f ‘,a1m);

> printf(‘a2=%12.9f ‘,a2m);

> printf(‘e =%12.9f\n‘,em);

> z:=solve(3*a0m*x^2+a1m*x-a2m,x):

> x1m:=z[1];

> x2m:=z[2];

> if x1m>x2m then h:=x1m; x1m:=x2m; x2m:= h; fi;

> printf(‘x1=%12.9f ‘,x1m);

> printf(‘x2=%12.9f\n‘,x2m);

> od:

Absolute Approximation

> pl1:=plot(f(x),x=0.0625..1,y=0..1,thickness=3,xtickmarks=4):

> pl2:=plot(p2(x),x=0.0625..1,thickness=1):

> pl7:=textplot([[0.7,0.76,‘f(x) = sqrt(x)‘],

> [0.4,0.4,‘p2(x) = -0.524x^2+1.319x+0.187‘],

> [0.085,0.02,‘1/16‘]]):


> title=‘Approximation p2(x) fuer f(x)=sqrt(x)‘);





> title=‘Approximation p2(x) fuer f(x)=sqrt(x)‘);


Relative Approximation

> pl2m:=plot(p2m(x),x=0.0625..1,y=0..1,thickness=1):

> pl7m:=textplot([[0.7,0.76,‘f(x) = sqrt(x)‘],

> [0.4,0.4,‘p2m(x) = -0.650x^2+1.442x+0.172‘],

> [0.085,0.02,‘1/16‘]]):

> plots[display]([pl1,pl2m,pl7m],

> title=‘Modifizierte Approximation p2m(x) fuer f(x)=sqrt(x)‘);




> plots[display]([pl1,pl2m,pl7m],

> title=‘Modifizierte Approximation p2m(x) fuer f(x)=sqrt(x)‘);



> f(x0)-p2m(x0);

> f(x1)-p2m(x1);

> f(x2)-p2m(x2);

> f(x3)-p2m(x3);

--------------------------------------------------------------------

Datei: nm8ip5.mws

Fourier-Reihenentwicklung (Fourier-Polynome, stetige Approximation

im Mittel) fuer f(x) mit Grafik

> restart:

> with(plots):

> with(plottools):












1.Funktion

f(x)=sign(sin(x))

> read ‘d:/neundorf/nwptexte/math93/cfourier.m‘;

> a:=-Pi; b:=Pi; T:=b-a;

> u1:=x->piecewise(x=-Pi,0,x<0,-1,x>0,1,0);

> # smartplot

> u1(x);

> smartplot(piecewise(x<0,-1,x>0,1,0));

> readlib(discont):

> discont(u1(x),x);

> plot(u1(x),x=a-1..b+1,-1..1,thickness=3,color=red);

> u2:=x->if x<0 then -1 elif x>0 then 1 else evalf(1/2) fi;


> u2(x);

> u2(0.5); # Error, (in u2) cannot evaluate boolean

> u3:=x->piecewise(x<a-T/2,-1,x<a,1,x<0,-1,x<b,1,x<b+T/2,-1,1);

> u3(x);

> plot(u3(x),x=-8..8,y=-1..1,thickness=2,title=‘u3(x)=sign(sin(x))‘);

> f1:=x->u1(x-T*floor((x-a)/T));

> f1(x);

> Q1:=plot([f1(x),sin(x)],x=-8..8,-1..1,thickness=2,color=black,

> title=‘f(x)=sign(sin(x))‘):

> Q2:=plot(f1(x),x=-8..8,-1.5..1.5,thickness=1,color=black):







Fourier-Polynom

Stetige Approximation im quadratischen Mittel

> cfourier(u1,a..b,8,‘reell‘,‘Plot‘);

> # W.Werner: Mathematik lernen mit Maple. dpunkt.verlag 1998

> bk:= k -> 2*(1-(-1)^k)/(Pi*k);

> bk(1); bk(2); bk(k);


> n:=’n’:

> pn:=(x,n)-> sum(bk(k)*sin(k*x),k=1..2*n+1);

> pn(x,n);

> pn(x,1);

> Q:=plot(pn(x,1),x=-8..8,-1.5..1.5,thickness=2,

> title=‘f(x)=sign(sin(x)), pn(x,1)=4/Pi*sin(x)+4/(3Pi)*sin(3*x)‘):


> P:=array(1..2,1..2,[]):

> n:=0:



> n:=n+1:


> if i*j=1 then

> P[i,j]:=plot([f1(x),pn(x,n)],x=-1..T+1,color=black,

> title=‘f(x) und Fourier-Polynome, n=1,2,3,4‘)

> else

> P[i,j]:=plot([f1(x),pn(x,n)],x=-1..T+1,color=black)

> fi:

> od:

> od:







2.Funktion

f(x)=x^2, -pi<=x<=pi

> v1:=x->piecewise(x<0,x^2,x>0,x^2,0);

> # smartplot

> v1(x);

> smartplot(piecewise(x<0,x^2,x>0,x^2,0));

> discont(v1(x),x);

> plot(v1(x),x=a-1..b+1,-10..10,thickness=3,color=red);

> v3:=x->piecewise(x<a-T,0,x<a,(x+(-a+T/2))^2,x<b,x^2,

> x<b+T,(x-(b+T/2))^2,0);

> v3(x);

> plot(v3(x),x=-10..10,y=-0..10,thickness=2,title=‘v3(x)=x^2‘);

> f2:=x->v1(x-T*floor((x-a)/T));

> f2(x);

> Q4:=plot(f2(x),x=-10..10,0..10,thickness=2,

> title=‘f(x)=x^2, -pi<=x<=pi‘):

> Q5:=plot(f2(x),x=-10..10,-1..10,thickness=1):







Fourier-Polynom

Stetige Approximation im quadratischen Mittel


> cfourier(v1,a..b,8,‘reell‘,‘Plot‘);

> ak:= k -> if k=0 then 2/3*Pi^2 else 4*(-1)^k/(k*k) fi;

> ak(0); ak(1); ak(2); ak(k);


> n:=’n’:

> qn:=(x,n)-> ak(0)/2+sum(ak(k)*cos(k*x),k=1..n);

> qn(x,n);

> qn(x,1);

> Q6:=plot(qn(x,1),x=-10..10,-1..10,thickness=2,

> title=‘f2(x)=x^2, qn(x,1)=Pi^2/3-4*cos(x)‘):

> plots[display]([Q5,Q6]);

> PP:=array(1..2,1..2,[]):

> n:=0:



> n:=n+1:

> if i*j=1 then

> PP[i,j]:=plot([f2(x),qn(x,n)],x=a-1..b+1,color=black,

> ytickmarks=3,title=‘f(x) und Fourier-Polynome, n=1,2,3,4‘)

> else

> PP[i,j]:=plot([f2(x),qn(x,n)],x=a-1..b+1,color=black,

> ytickmarks=3)

> fi:

> od:

> od:

> plots[display](PP);




> plots[display](PP);


-------------------------------------------------------------------

Datei: nm8ip6.mws

Stetige Approximation im Mittel

Faltungsschema von Runge

> restart:

> with(plots): with(plottools):

> with(linalg):




> # Graphik output files





1.Faltung

> pl1:=plot([sin(x),cos(x)],x=0..2*Pi,y=-1.5..1.5,

> thickness=1,xtickmarks=6,color=black):

> pl2:=plot([[Pi,-1.5],[Pi,1.5]],thickness=3,color=black):

> pl3:=plot([[2*Pi,-0.1],[2*Pi,1]],thickness=1,color=black):

> pl4:=textplot([[5,0.7,‘cos(x)‘],[6,-0.6,‘sin(x)‘],[3.3,0.1,‘Pi‘]]):

> plots[display]([pl1,pl2,pl3,pl4],title=‘1.Faltung bei x=Pi‘);




> plots[display]([pl1,pl2,pl3,pl4],title=‘1.Faltung bei x=Pi‘);


2.Faltung

> ql1:=plot([sin(x),cos(x)],x=0..Pi,y=-1.5..1.5,

> thickness=1,xtickmarks=3,color=black):

> ql2:=plot([[Pi/2,-1.5],[Pi/2,1.5]],thickness=3,color=black):

> ql3:=plot([[Pi,0.1],[Pi,-1]],thickness=1,color=black):

> ql4:=textplot([[2.8,0.6,‘sin(x)‘],[2.8,-0.7,‘cos(x)‘],

> [1.7,0.1,‘Pi/2‘]]):

> plots[display]([ql1,ql2,ql3,ql4],title=‘2.Faltung bei x=Pi/2‘);




> plots[display]([ql1,ql2,ql3,ql4],title=‘2.Faltung bei x=Pi/2‘);



Fourier-Reihenentwicklung

Maple-Prozedur cfourier.m nach W. Werner

% cfourier.m

% Fourier-Reihenentwicklung fuer F(x) in a..b mit n Knoten

> a:=-2; b:=2; n:=6;

> f:=x->piecewise(x<0,1,x>0,0,1/2);

> cfourier(u0,a..b,n,‘reell‘,‘Animation‘);

proc(F::procedure, U::range, m::integer)

local a, b, alpha, beta, k, n, T, c, c0, c1, c2, c3, ac, bc,

f, fc, u, v, om, opt, p, q, nA, nP, FourierSum, ParsevalSum,

FS, PS, AS, Ausn, QuadrMtl, Var, Vereinf, Koeff, brll, bkmplx,

bpars, bplot, bspkt, bgraf, banm, fopt, i, M;

if trunc(time()) mod 3 = 0 then

print(‘cfourier ist dem Buch‘);

print(‘W.Werner, Mathematik lernen mit Maple‘);

print(‘dpunkt.verlag, Heidelberg, 1998‘);

print(‘ISBN 3-920993-94-2‘);

print(‘entnommen.‘)

fi;

with(plots);

fopt := {};

for k from 4 to nargs do fopt := fopt union {args[k]} od;

brll := member(reell, fopt);

bkmplx := member(komplex, fopt);

bpars := member(Parseval, fopt);

bgraf := member(Graph, fopt);

bplot := member(Plot, fopt);

bspkt := member(Spektrum, fopt);

banm := member(Animation, fopt);

f := unapply(map(convert, F(t), rational), t);

p := array(1 .. 2);

alpha := op(1, U);

beta := op(2, U);

T := beta - alpha;

om := 2*Pi/T;

c0 := normal(int(f(t), t = U)/T);

c := unapply(

int(f(t)*(cos(om*u*t) - I*sin(om*u*t)), t = U)/T, u);

Var := select(type,


(indets(f(t)) minus {t}) union indets(U), name);

for k to nops(Var) do assume(op(k, Var), real) od;

if 0 < nops(Var) then print(

‘Hinweis: Evtl. Annahme z.B. ‘, op(Var),

‘ "nicht ganzzahlig" noetig.‘)

fi;

Ausn := select(type, {solve(denom(normal(c(u))) = 0, u)},

integer);

nA := nops(Ausn);

fc := proc(c, Ausn, n)

if member(n, Ausn) then limit(c(u), u = n)

else normal(simplify(c(n)))

fi

end;

assume(n, integer);

assume(t, real);

interface(showassumed = 0);

c1 := op(map(op, [seq(

[’n’ = Ausn[k], fc(c, Ausn, Ausn[k])], k = 1 .. nA)]))

;

Ausn := select(t -> evalb(0 <= t), Ausn);

nP := nops(Ausn);


[’n’ = Ausn[k], evalc(2*Re(fc(c, Ausn, Ausn[k])))],

k = 1 .. nP)]));


[’n’ = Ausn[k], evalc(-2*Im(fc(c, Ausn, Ausn[k])))],

k = 1 .. nP)]));

Vereinf := proc(expr, n)

factor(normal(subs(

{((-1)^n)^2 = 1, (-1)^(2*n) = 1}, evalc(expr))))

end;

u := Vereinf(c(n), n);

if bkmplx then

print(‘Komplexe Fourierkoeffizienten:‘);

if 0 < nA then print(c[n] = piecewise(c1, u))

else print(c[n] = u)

fi

fi;

a := ’a’;

b := ’b’;

if brll then

print(‘Reelle Fourierkoeffizienten:‘);


if 0 < nA then

u := Vereinf(2*Re(expand(c(n))), n);

v := Vereinf(-2*Im(expand(c(n))), n);

print(a[n] = piecewise(c2, u),

b[n] = piecewise(c3, v))

else print(a[n] = normal(evalc(2*Re(c(n)))),

b[n] = normal(evalc(-2*Im(c(n)))))

fi

fi;

k := ’k’;

Koeff := [seq(evalc(fc(c, Ausn, k)), k = 1 .. m)];

k := ’k’;

FS := add(Koeff[k]*exp(I*k*om*t), k = 1 .. m);

FourierSum := map(factor, map(conjugate, FS) + c0 + FS);

if bkmplx then

print(‘Komplexe Fourierreihe: ‘);

print(f(t) = Sum(c[n]*exp(I*n*om*t),

n = -infinity .. infinity), ‘=‘);

print(‘=‘, FourierSum, ‘+...‘)

fi;

u := ‘if‘(0 < nA, max(op(Ausn)), 0);

FS := fc(c, Ausn, 0) + map(simplify,

add(2*Re(fc(c, Ausn, k))*cos(k*om*t), k = 1 .. m));

FourierSum := FS - map(simplify,

add(2*Im(fc(c, Ausn, k))*sin(k*om*t), k = 1 .. m));

if brll then

print(‘Reelle Fourierreihe: ‘);

print(f(t) = 1/2*a[0]

+ Sum(a[n]*cos(n*om*t), n = 1 .. infinity)

+ Sum(b[n]*sin(n*om*t), n = 1 .. infinity), ‘=‘)

;

print(‘=‘, FourierSum, ‘+...‘)

fi;

QuadrMtl := int(f(t)^2, t = U)/T;

if bpars then

print(‘Parsevalsche Gleichung: ‘);

PS := add(abs(fc(c, Ausn, k))^2, k = 1 .. u) + Sum(

Vereinf(abs(c(n)^2), n), n = u + 1 .. infinity);

print(map(normal, QuadrMtl = fc(c, Ausn, 0)^2 + 2*PS))

fi;

if nops(Var) = 0 then

QuadrMtl := evalf(Int(f(t)^2, t = U))/T;

Digits := 3;


u := evalf(sqrt(QuadrMtl));

opt := xtickmarks = [-evalf(T), 0, evalf(T)],

ytickmarks = [-u, u], color = black,

thickness = [2, 1], title = Fourierreihe;

Digits := 10;

q := array(1 .. 2, []);

p[1] := plot(

[f(t - floor((t - alpha)/T)*T), FourierSum],

t = -T .. T, discont = true, opt);

AS := seq(POLYGONS(map(evalf, [

[om*k, 0], [2*Pi*k/T, evalf(abs(fc(c, Ausn, k)))]

]), THICKNESS(2)), k = 1 .. 20);

with(plots);

p[2] := PLOT(AS, TITLE(Amplitudenspektrum));

if bgraf then display(p, scaling = constrained)

elif bplot then

display(p[1], scaling = unconstrained)

elif bspkt then

print(display(p[1], scaling = unconstrained));

print(display(p[2], scaling = unconstrained))

elif banm then

i := ’i’;

for i to m do

FS := fc(c, Ausn, 0) + map(simplify, add(

2*Re(fc(c, Ausn, k))*cos(k*om*t),

k = 1 .. i));

M[i] := plot([f(t - floor((t - alpha)/T)*T),

FS - map(simplify, add(

2*Im(fc(c, Ausn, k))*sin(k*om*t),

k = 1 .. i))], t = -T .. T,

title = cat(i), color = [blue, red])

od;

display([seq(M[i], i = 1 .. m)],

insequence = true)

fi

fi

end

Documents

Numerische Mathematik€¦ · die wie kleine Maple-Nutzerhandbuc her zu den folgenden Gebieten untersetzt mit vielen Beispielen genutzt werden k onnen. - Formeln, Ausdr uc ke und