TI-Basic: Programme und Tutorials: Funktionsanalyse

Hoch zu "Programme und Tutorials"

Erstellt von:	Peter Riedel
Schwierigkeitsgrad:	fortgeschritten
Modell:	Voyage 200

Funktionsanalyse

Dieses Programm soll ein mächtiges und umfangreiches Werkzeug zur Analyse von reellen Funktionen(-scharen) werden und befindet sich momentan noch in der Entwicklung. Das Hauptprogramm wird wegen der Übersichtlichkeit nicht den gesamten Quelltext enthalten, sondern Unterprogramme aufrufen, die entsprechende Aufgaben bewältigen, damit man noch einen Überblick über das gesamte Programm behält und um Unterprogramme einfach und schnell auskommentieren zu können, falls man beim Testen nur einen Teil und nicht das ganze Programm überprüfen möchte. Weitere Pläne sind ein Menü über das man individuell das anfordern kann, was man über die Funktion wissen will.

:analysis(function)
:Prgm
:domain(function)
:codomain(function)
:derivats(function)
:zero(function)
:limits(function)
:...
:EndPrgm

Definitionsbereich

Der Definitionsbereich legt fest, für welche Werte die Funktion definiert ist. Bei diesem Unterprogramm geht es darum, herauszufinden, für welche x-Werte die Funktion f(x) nicht definiert ist. Das kann der Fall sein, wenn der Nenner eines Bruches Null ergibt oder der Radikand einer Wurzel kleiner als Null ist. Genau das soll mit folgendem Programm überprüft werden. Definitionslücken können natürlich nur entstehen, wenn die Variable x selbst im Nenner oder Radikand enthalten ist. Als Ergebnis wird der für die Funktion geltende Definitionsbereich ausgegeben. Die eigentliche Schwierigkeit besteht darin, dass im Nenner /(...) oder Radikand √(...) im inneren weitere Klammerungen (...) sein können, die ebenfalls wiederholt ausgelesen werden müssen, um festzustellen, auf welcher Position sich die schließende Klammer des Nenners oder Radikands sich wirklich befindet.

:domain(function)
:Prgm
:ClrIO
:If function=undef Then
:  Disp "x ist nicht das Element von R"
:  Return
:EndIf
:string(function)→str
:{}→xlist
:0→frac
:Lbl a
:inString(str,"/",frac+1)→frac
:If frac≠0 and mid(str,frac+1,1)≠"(" and (mid(str,frac+1,1)="x" or mid(str,frac+2,1)="x") Then
:  augment(xlist,{0})→xlist
:  Goto a
:EndIf
:0→fracopen
:Lbl b
:inString(str,"/(",fracopen+1)→fracopen
:If fracopen≠0 Then
:  inString(str,")",fracopen+3)→fracend
:  fracopen→nfracop
:  Lbl c
:  If inString(str,"(",nfracop+2)<fracend-3 and inString(str,"(",nfracop+2)≠0 Then
:    inString(str,"(",nfracop+2)→nfracop
:    inString(str,")",fracend+1)→fracend
:    Goto c
:  EndIf
:  expr(mid(str,fracopen+2,fracend-fracopen-2))→nomi
:  augment(xlist,zeros(nomi,x))→xlist
:  Goto b
:EndIf
:0→rootopen
:Lbl d
:inString(str,"√(",rootopen+1)→rootopen
:If rootopen≠0 Then
:  inString(str,")",rootopen+3)→rootend
:  rootopen→nrootop
:  Lbl e
:  If inString(str,"(",nrootop+2)<rootend-3 and inString(str,"(",nrootop+2)≠0 Then
:    inString(str,"(",nrootop+2)→nrootop
:    inString(str,")",rootend+1)→rootend
:    Goto e
:  EndIf
:  expr(mid(str,rootopen+2,rootend-rootopen-2))→rt
:  dim(xlist)→count
:  solve(rt<0,x)→xlist[count+1]
:  Goto d
:EndIf
:Disp "Definitionsbereich:"
:If xlist={} Then
:  Disp "x ∈ R"
:Else
:  Disp "x ∈ R \ "&string(xlist)
:EndIf
:Pause
:EndPrgm

Ableitungen

:derivats(function)
:Prgm
:ClrIO
:d(function,x)→derivat1
:d(derivat1,x)→derivat2
:d(derivat2,x)→derivat3
:Disp "Funktion:","f(x) = "&string(function)
:Disp "1. Ableitung:","f′(x) = "&string(derivat1)
:Disp "2. Ableitung:","f′′(x) = "&string(derivat2)
:Disp "3. Ableitung:","f′′′(x) = "&string(derivat3)
:Pause
:EndPrgm

Nullstellen

:zero(function)
:Prgm
:ClrIO
:zeros(function,x)→list
:dim(list)→count
:If count=0 Then
:  Disp "keine Nullstelle"
:  Disp string(function)&" ≠ 0"
:ElseIf count=1 Then
:  string(list[1])→l1
:  dim(l1)→count
:  0→inf
:  For i,1,count
:    If mid(l1,i,1)="@" Then
:      1→inf
:      0→prsgnloc
:      0→posgnloc
:      0→at
:      For i,1,count
:        mid(l1,i,1)→c
:        If c="+" or c="-" or c="*" or c="/") Then
:          posgnloc→prsgnloc
:          i→posgnloc
:          If at=1
:            Exit
:        ElseIf c="@" Then
:          1→at
:        EndIf
:      EndFor
:      left(l1,prsgnloc)&"z"&right(l1,count-posgnloc+1)→list
:      Exit
:    EndIf
:  EndFor
:  If inf=0 Then
:    Disp "Nullstelle: "&string(function)&" = 0 für"
:    If list[1]≥0 Then
:      Disp "x = "&string(list[1])
:    Else
:      Disp "x ="&string(list[1])
:    EndIf
:  Else
:    Disp "unendlich Nullstellen: "&string(function)&" = 0 für"
:    Disp "x = "&list
:    Disp "z ∈ Z = {-∞,...,-2,-1,0,1,2,...,∞}"
:  EndIf
:Else
:  Disp "Nullstellen: "&string(function)&" = 0 für"
:  For i,1,count
:    If list[i]≥0 Then
:      Disp "x"&string(i)&" = "&string(list[i])
:    Else
:      Disp "x"&string(i)&" ="&string(list[i])
:    EndIf
:  EndFor
:EndIf
:EndPrgm

Grenzwerte für x→±∞

:limits(function)
:Prgm
:ClrIO
:Disp "Grenzwerte für x→±∞:"
:If limit(function,x,∞)≥0 Then
:  Disp " lim "&string(function)&" = "&string(limit(function,x,∞)),"x→ ∞"
:Else
:  Disp " lim "&string(function)&" ="&string(limit(function,x,∞)),"x→ ∞"
:EndIf
:If limit(function,x,-∞)≥0 Then
:  Disp " lim "&string(function)&" = "&string(limit(function,x,-∞)),"x→-∞"
:Else
:  Disp " lim "&string(function)&" ="&string(limit(function,x,-∞)),"x→-∞"
:EndIf
:EndPrgm