demo

________________________________________________________________________________

Inhalt....: Die Funktionen des 'analysis'-Packages
Kategorie.: Package
Mathematik: Analysis
MuPAD.....: 3.0.0
Datum.....: 2003-02-11
Autoren...: MuPAD Schule-Team <schule@mupad.de>
________________________________________________________________________________

Das analysis-Package

Das vorliegende Dokument beschreibt anhand von Beispielen den Umgang mit dem MuPAD
Package 'analysis'- und seinen Funktionen.

Laden und Initialisierung des Paketes erledigen wir wie folgt:

package("analysis"):
analysis::init():
export(analysis):

Wir wollen das Package an einigen elementaren Beispielen kennenlernen. Wir
beginnen mit Folgen und gehen dann über zu Funktionen, der Differenzial- und
schließlich der Integralrechnung.

Der Umgang mit Folgen

Zunächst wollen wir einige Folgen mit Hilfe des Packages analysis definieren.
Für diesen Zweck steht im Package der spezieller Operator --> zur Verfügung:

a:= n +-> n^2

Einzelne Folgenglieder berechnen wir mit der aus der Schule üblichen Syntax:

a(12)

Wichtig ist zu beachten, dass Folgen explizit als Funktionen über den natürlichen
Zahlen definiert sind. Die folgenden Befehlszeilen führen also absichtlich zu
Fehlermeldungen:

a(0)

Error: Folge ist nur fuer natuerliche Werte definiert
[analysis::Folge::func_call]

a(-2.1)

Error: Folge ist nur fuer natuerliche Werte definiert
[analysis::Folge::func_call]

a(12.0)

Error: Folge ist nur fuer natuerliche Werte definiert
[analysis::Folge::func_call]

a(cos(0)+2)

Die letzte Zeile zeigt, dass MuPAD trotzdem immer vorerst Vereinfachungen
vornimmt und damit sicherstellt, dass eine natürliche Zahl nicht in "verklausulierter"
Form eingegeben wurde (cos(0)+2 vereinfacht sich zu 3).

Wir wollen ein wenig mit Folgen rechnen. Zunächst definieren wir uns drei
verschiedene Zahlenfolgen:

a := n +-> 1/n

b := n +-> sin(n)

c := n +-> (-1)^n / (n^2)

Es lassen sich nun die üblichen Rechenoperationen mit ihnen ausführen:

10 * a

20 * b

30 * c

a * 3

Auch die Anwendung einer Funktion auf eine Folge ist möglich:

b:= m +-> m^2

sin@b

sqrt(b)

Wertetabellen von Folgen erstellt man mit Hilfe des Befehls wertetabelle:

wertetabelle(n +-> sin(n), n = 2..10)

wertetabelle(n +-> sin(n), n = 1..10, 20, 30, 34, 41..43)

float(%)


[[1.0, 0.8414709848], [2.0, 0.9092974268], [3.0, 0.1411200081],

   [4.0, -0.7568024953], [5.0, -0.9589242747], [6.0, -0.2794154982],

   [7.0, 0.6569865987], [8.0, 0.9893582466], [9.0, 0.4121184852],

   [10.0, -0.5440211109], [20.0, 0.9129452507], [30.0, -0.9880316241],

   [34.0, 0.5290826861], [41.0, -0.1586226688], [42.0, -0.9165215479],

   [43.0, -0.8317747426]]

Zur Visualisierung von Folgen bietet das Package die Möglichkeit, Graphen von
Wertetabellen zeichnen zu lassen:

a:= n +-> 1/n:

meineTabelle:= wertetabelle(a, 1..10, 20, 30, 40..50):

meinePunkte:= graph(meineTabelle):

plot(%)

In der Regel möchte man aber nicht immer erst eine Wertetabelle einer Folge
erstellen, sondern diese direkt mit MuPAD zeichnen lassen. Auch dieses ist
möglich:

plot(graph(a, 1..10))

Die Größe der gezeichneten Punkte kann mit Hilfe des Attributs PointSize
direkt in Millimetern festgelegt werden:

plot(graph(a, 1..10), PointSize = 3*unit::mm)

Die in der Grafik-Bibliothek von MuPAD üblichen Standardoptionen, wie z.B.
das Einfügen von Gitterlinien mittels GridVisible = TRUE, stehen na-
türlich auch hier zur Verfügung:

plot(graph(a, 1..10), GridVisible = TRUE)

Auch lassen sich verschiedene Folgen mit unterschiedlichen, vom Benutzer
definierten Farben darstellen:

plot(
graph(a, 2..20, Color = RGB::Blue),
graph(2*a, 2..20,
Color = RGB::Red)
)

Definiert man sich selbst kleine Prozeduren, die Zahlenfolgen beschreiben,
so lassen sich auch diese später in die für das analysis-Package übliche
Form konvertieren. Wir betrachten hier das Beispiel der so genannten
Collatz-Folge:

collatz := proc(n, list = [])
// Baut eine Liste gem. obiger Definition auf,
// die zunächst leer ist.
begin
    if n = 1 then
        return( list.[1] )
    elif n mod 2 = 0 then
        return( collatz(n/2, list.[n]) )
    else
        return( collatz(3*n + 1, list.[n]) )
    end
end:

a := n +-> hold( nops(collatz(n)) ):

collWerte := wertetabelle(a, n = 1..100):

collPunkte := graph(collWerte):
plot(collPunkte)

Zur Visualisierung von Konvergenz oder Häufungspunkten bietet die Funktion
Folge::visLim des analysis-Packages eine hervorragende Möglichkeit:

plot(Folge::visLim( n +-> 1/n, n = 2..50 ))

vl:= Folge::visLim( n +-> (-1)^n*1/n, n = 10..50 ):
plot(vl)

plot( Folge::visLim(n +-> sin(n), n = 10..50) )

a:= n +-> sin(n) / n:

avl:= Folge::visLim(a, n = 10..40): plot(avl)

b:= n +-> 1/n:

untereSchranke := Folge::visLim( -b, n = 10..40,
                                 Color = RGB::Blue ):
obereSchranke  := Folge::visLim( b, n = 10..40,
                                 Color = RGB::Blue ):

plot(avl, untereSchranke, obereSchranke)

spezFolge := proc(n)
begin
    if n mod 2 = 0 then
        // Fall (a):
        return( 5 + 1/n )
    else
        // Fall (b):
        return( sin(n)/sqrt(n) )
    end
end:

a := n +-> hold(spezFolge(n)):
plot( Folge::visLim(a, n = 1..100) )

Im Kontext von Folgen darf natürlich auch die berühmte Fibonacci-Folge nicht
fehlen:

fib := proc(n)
    local fib_rek;
begin
    // Rekursiver Teil:
    fib_rek := proc(n, vorherige, diese)
    begin
        if n = 0 then
            // Bei 0 gebe vorherige zurück
            return( vorherige )
        else
           // Sonst gebe (vorherige + diese) = naechste
           // weiter in die Rekursion:
           return( fib_rek(n - 1, diese, vorherige + diese) )
        end
    end:

    return( fib_rek(n, 0, 1) )
end:

af := n +-> hold(fib(n - 1))

plot(graph(af, n = 1..10))

Der Umgang mit Funktionen

Jetzt wollen wir sehen, wie wir Funktionen mit Hilfe des Packages analysis
definieren. Zur Definition von Funktionen steht auch wieder ein speziell für
diese Zweck vorgesehener Operator zur Verfügung:

f:= x :-> ln(x): a:= n +-> ln(n):

plot(
graph(f, 1..10, Color = RGB::Red),
graph(a + 2, 1..10, Color = RGB::Black)
)

Unterschiede von Funktionen und Folgen lassen sich so schön herausstellen:

schranke:= k :-> 1/k: a := n +-> sin(n)/n:

f:= x :-> sin(x)/x:

plot(
    graph(schranke, 1..20, Color = RGB::Red),
    graph(a, 1..20),
    graph(-schranke, 1..20, Color = RGB::Red)
)

b:= n +-> ln(n): g:= x :-> ln(x):

bPlot:= graph(b, 1..10, Color = RGB::Red):
gPlot:= graph(g, 0.5..10, Color = RGB::Gray):

plot(bPlot, gPlot)

Auch Tangenten und Geraden stehen im analysis-Package als eigene
"Datentypen" bereit:

f:= x :-> x^2: tf2:= tangente(f, Stelle = 2)

gf:= graph(f, 0..4):
gtf2:= graph(tf2, 0..4):
gf::Color:= RGB::Green:
plot(gf, gtf2)

t:= tangente(f, Xo)

gerade(m = 2, [0, 3], x)

gerade([2, 3], [4, 4], x)

Zur Einführung der Differenzialrechnung wird der Differenzenquotient von
Funktionen betrachtet und anschließend spezielle Grenzwerte betrachtet.
Auch diese mathematischen Sachverhalten lassen sich mit dem analysis-
Package am Rechner umsetzen:

f:= x :-> sign(x - 1):
a:= n +-> 1+1/n: b := n +-> 1-1/n:

limit(f@a)

limit(f@b)

dQ:= differenzenQuotient(x :-> x^2, Xo, h)

limit(dQ, h = 0)

dQ:= differenzenQuotient(x :-> x^2, Xo = 3, h)

limit(dQ, h = 0)

f:= x :-> abs(x):
dQ := differenzenQuotient(f, Xo = 0, h):

Zum Ersetzen von Ausdrücken und/oder Variablen in Funktionen oder
Folgen, kann der Befehl ersetzen verwendet werden:

af:= ersetzen(a, h = 1/n)

ag := ersetzen(a, h = -1/n)

limit(af, n = infinity); limit(ag, n = infinity)

Das Package ermöglicht es weiterhin, auch zusammengesetzte (stückweise
definierte) Funktionen zu betrachten:

fz:= x &-> (sin(x), Dom::Interval(-infinity, 0),
cos(x) - 1, Dom::Interval([0], infinity))


                   +-                                 -+
                   |                                   |
                   |    sin(x),   x in (-infinity, 0)  |
                   |                                   |
                   |                                   |
                   |  cos(x) - 1,  x in [0, infinity)  |
                   +-                                 -+

plot(graph(fz, Bereich = -3..3))

Zugriff auf die entsprechenden Teilintervalle und Teilfunktionen einer
stückweise definierten Funktion erhalten wir wie folgt:

zusFunktion::intervalle(fz)

zusFunktion::funktionen(fz)

teilf:= zusFunktion::teilFunktionen(fz)


 --                                                                     --
 |  +-                           -+  +-                              -+  |
 |  | sin(x), x in (-infinity, 0) |, | cos(x) - 1, x in [0, infinity) |  |
 -- +-                           -+  +-                              -+ --

Wie üblich zeichnen wir Graphen mit Hilfe des plot-Befehls:

plot(graph(teilf[1], Bereich = -3..3))

plot(graph(teilf[2], Bereich = -3..3))

fz:= x &-> (sin(x), Dom::Interval(-infinity, 0),
cos(x), Dom::Interval(0, infinity),
x :-> 0.5, 0)


                     +-                             -+
                     |                               |
                     |  sin(x), x in (-infinity, 0)  |
                     |                               |
                     |                               |
                     |  cos(x),  x in (0, infinity)  |
                     |                               |
                     |    0.5,        x in {0}       |
                     +-                             -+

plot(graph(fz, Bereich = -3..3))

Es ist natürlich nicht erlaubt, stückweise definierte Funktionen zu betrachten,
bei denen sich die Definitionsbereiche der Teilfunktionen überschneiden.
In diesem Fall erhalten wir eine Fehlermeldung:

fz2:= x &-> ( sin(x), Dom::Interval(-3, 1),
x^2, Dom::Interval(0, 3) )

Error: Die Definitionsbereiche der Teilfunktionen
ueberdecken sich [analysis::zusFunktion::new]

fz2:= x &-> ( sin(x), Dom::Interval(-3, 1),
x^2, Dom::Interval(1, 3) )


                        +-                      -+
                        |                        |
                        |  sin(x), x in (-3, 1)  |
                        |                        |
                        |     2                  |
                        |    x ,    x in (1, 3)  |
                        +-                      -+

Auch das Auswerten von Funktionen an Stellen, an denen Sie nicht definiert
sind, wird mit einer entsprechenden Fehlermeldung geahndet:

fz2(1)

Error: Die Funktion ist an der Stelle 1 nicht definiert
[analysis::zusFunktion::func_call]

Differenziation und Integration

Wie man die üblichen Handgriffe im Kontext der Differenziation und Integration
erledigt, wehen wir im folgenden:

f:= x :-> sin(x) * cos(x)

diff(f)

Im Gegensatz zu den üblichen Funktionalitäten der "bloßen Berechnung" von
Ergebnissen, bietet das Package die Möglichkeit, sich so genannte Ableitung-
bäume ausgeben zu lassen, die Auskunft darüber geben, welche Regeln zur
Berechnung der jeweiligen Ableitung verwendet wurden:

ablBaum:= ableitung(f):

expose(ablBaum)


          diff(cos(x)*sin(x))
          |
          `-- Produktregel
              |
              +-- (u * v)' = u'v + v'u
              |
              +-- cos(x)
              |   |
              |   `--  = u, u' = -sin(x)
              |
              +-- sin(x)
              |   |
              |   `--  = v, v' = cos(x)
              |
              `-- diff(cos(x), x)*sin(x) + diff(sin(x), x)*cos(x)
                  |
                  `-- Endergebnis

Auch Zwischenergebnisse lassen sich ausgeben:

zwischenErg:= knoten(ablBaum)

Mit ihnen kann dan weitergerechnet werden:

u:= zwischenErg[2]: v:= zwischenErg[3]:

u'*v + v'*u

eval(zwischenErg[4])

Die MuPAD Standard-Funktion int zur Integration kann auch auf Funktionen
angewendet werden, die mit dem Package definiert wurden:

int(x^2*sin(x),x)

int(x :-> x^2*sin(x))

Die Funktion intTip liefert Lösungshinweise bei zur Berechnung von Integralen:

ergebnisBaum:= intTip(x^2 + sin(x)):
expose(ergebnisBaum)


           int(sin(x) + x^2, x)
           |
           `-- Summenregel
               |
               +-- int( S1 + S2 ) dx = int( S1 )dx + int( S2 )dx
               |
               +-- sin(x)
               |   |
               |   `-- = S1
               |
               `-- x^2
                   |
                   `-- = S2

Auf die Knoten derartiger "Struktur"-Bäume kann mit Hilfe des Befehls knoten
zugegriffen werden:

integrationsregel:= knoten(ergebnisBaum)[1]

ersterSummand:= knoten(ergebnisBaum)[2]

zweiterSummand:= knoten(ergebnisBaum)[3]

tip_ersterSummand:= intTip(ersterSummand):
knoten(tip_ersterSummand)[1]

tip_zweiterSummand:= intTip(zweiterSummand):
knoten(tip_zweiterSummand)[1]

ergebnisBaum:= intTip(x^2*sin(x)): expose(ergebnisBaum)


                int(x^2*sin(x), x)
                |
                `-- partielle Integration
                    |
                    +-- int(u v') dx = u * v - int(u' v) dx
                    |
                    +-- x^2
                    |   |
                    |   `-- = u
                    |
                    `-- sin(x)
                        |
                        `-- = v'

integrationsverfahren:= knoten(ergebnisBaum)[1]

u:= knoten(ergebnisBaum)[2]

vStrich:= knoten(ergebnisBaum)[3]

f:= x/sqrt(25-x^2)

ergebnisBaum:= intTip(f): expose(ergebnisBaum)


            int(x/(25 - x^2)^(1/2), x)
            |
            `-- Integration durch Substitution
                |
                +-- int( f(g(x)) * g'(x) )dx = int( f(z1) )dz1
                |
                `-- z1 = 25 - x^2
                    |
                    `-- Substitutionsgleichung

substitutionsgleichung:= knoten(ergebnisBaum)[2]

Die Prozedur integriere gibt zusätzliche Informationen:

ergebnisBaum := integriere( x*cos(x),
Modus = "PartInt",
"u" = x ):

expose(ergebnisBaum)


               int(x*cos(x), x)
               |
               `-- Partielle Integration
                   |
                   +-- int( u v' )dx = u * v - int( u' v )dx
                   |
                   +-- x
                   |   |
                   |   `-- gewaehltes u, u' = 1
                   |
                   +-- cos(x)
                   |   |
                   |   `-- = v' , v = sin(x)
                   |
                   +-- x*sin(x)
                   |   |
                   |   `-- = u v
                   |
                   +-- sin(x)
                   |   |
                   |   `-- Restintegrand u' v
                   |
                   `-- x*sin(x) - int(sin(x), x)
                       |
                       `-- Ergebnis

u_v:= knoten(ergebnisBaum)[4]

restintegrand:= knoten(ergebnisBaum)[5]

meinErgebnis:= u_v - int(restintegrand,x)

unevaluiertesErgebnis:= knoten(ergebnisBaum)[6]

evaluiertesErgebnis:= eval(unevaluiertesErgebnis)

Korrektheit von Ergebnissen kann mit Hilfe istgleich von überprüft
werden.

istgleich( meinErgebnis = evaluiertesErgebnis )

f:= exp(5*x-10):
ergebnisBaum := integriere(f,Modus="Substitution", z =5*x-10,
x = (z+10)/5):

expose(ergebnisBaum)


      int(exp(5*x - 10), x)
      |
      `-- Integration durch Substitution
          |
          +-- int( f(g(x)) * g'(x) )dx = int( f(z) )dz
          |
          +-- 5*x - 10
          |   |
          |   `-- = z :  Substitution, x = 1/5*z + 2
          |
          +-- dx = 1/5*dz
          |   |
          |   `-- Differential
          |
          +-- 1/5*exp(z)
          |   |
          |   `-- Integrand der substituierten Funktion
          |
          +-- int(1/5*exp(z), z)
          |   |
          |   `-- int ueber den Integrand der substituierten Funktion
          |
          `-- subs(int(1/5*exp(z), z), z = 5*x - 10)
              |
              `-- Ergebnis

Diverse weitere Funktionalitäten des Packages

1. Numerische Bestimmung von Nullstellen mit Hilfe des Newton-Verfahrens:

nsNewton(x^2-4, Start = 1.0)

2. Visualisierung zur numerischen Bestimmung von Nullstellen mit Hilfe des
Newton-Verfahrens

newt := graphNewton(x^2-4, Start = 1.0, x = 0..4):
plot(newt)

________________________________________________________________________________

Anmerkungen:

1. Weitere Anregungen finden Sie in der Buchreihe Mathematik 1 x anders. Dort werden unterschiedlichste
mathematischer Probleme mit MuPAD gelöst. Unter www.mupad.de/schule+studium/literatur stehen sie
kostenfrei zum Download bereit.
_______________________________________________________________________________