%htmlDTD; ]> Automatische Berechnung von Grenzwerten und Implementierung in Mathematica Zurück - Inhalt - Übersicht - Vorwärts

5 Details der Implementierung

Zurück - Inhalt - Übersicht - Vorwärts

5.1 Paketdokumentation

Die Paketdokumentation ist Teil des Mathematica-Paketes MrvLimit und steht auf der Projekt-Webseite zum Download bereit. Es existiert auch eine komplett in Englisch verfasste Version der Paketdokumentation.

5.1.1 Laden des Pakets

Das Paket wird wie jedes andere Mathematica-Paket mit Needs oder Get geladen.

Ist die Datei MrvLimit.m in einem Verzeichnis des Mathematica-Suchpfads $Path, kann das Paket direkt geladen werden:
In[1]:=
Needs [ MrvLimit` ]
MrvLimit v1.0 © 2005 by Udo Richter
mail: udo_richter(at)gmx.de
web: http://urichter.cjb.net/MrvLimit
Released under the GNU General Public License.
Andernfalls muss beim Laden der komplette Pfad zur Datei angegeben werden:
In[2]:=
Needs [ MrvLimit` , Pfad/Zur/Datei/MrvLimit.m ]
MrvLimit v1.0 © 2005 by Udo Richter
mail: udo_richter(at)gmx.de
web: http://urichter.cjb.net/MrvLimit
Released under the GNU General Public License.
Wird das Paket nur innerhalb eines anderen Pakets benötigt, kann es auch 'stillschweigend' geladen werden:
In[3]:=
MrvLimit`MrvLimitLoadSilent = True ;
In[4]:=
Needs [ MrvLimit` ]

5.1.2 Einfache Grenzwertberechnungen

Einfache Grenzwertberechnungen können analog zu Mathematicas Limit-Funktion durchgeführt werden:
In[5]:=
f = x 2 ( x + 1 ) ( x - 1 ) ;
In[6]:=
MrvLimit [ f , x ]
Out[6]=
1
Falls ein eindeutiger Grenzwert nicht existiert, kann die Richtung der Annäherung vorgegeben werden:
In[7]:=
MrvLimit [ f , x 1 , Direction - 1 ]
Out[7]=
Dabei bedeutet -1 eine Annäherung von oben, +1 eine Annäherung von unten und 0 eine beidseitige Annäherung. Falls MrvLimit im beidseitigen Modus auf eine Unstetigkeit trifft, werden beide einseitigen Grenzwerte als Liste ausgegeben:
In[8]:=
MrvLimit [ f , x 1 ]
Out[8]=
{ - , }
Als optisch ansprechende Variante kann die Richtung der Annäherung durch ein hochgestelltes + oder - am Grenzwert angegeben werden:
In[9]:=
MrvLimit [ f , x 1 + ]
Out[9]=
Sollte MrvLimit einen Grenzwert nicht korrekt berechnen können, wird eine entsprechende Warnmeldung ausgegeben, und die Grenzwertaufgabe wird unausgewertet zurück geliefert:
In[10]:=
MrvLimit [ Sin [ 1 / x ] , x 0 ]
MrvLimit :: UnsupportedArgument : MrvLimit does not support Sin [ x ] for x , appearing in Sin [ x ]
Out[10]=
MrvLimit [ Sin [ 1 x ] , x 0 ]
Die Spezialität des MrvLimit-Algorithmus liegt dabei insbesondere bei Funktionen mit verschachtelten Exponential- und Logarithmusfunktionen:
In[11]:=
f = x ( - 1 x - - x + - x + - x 2 + 1 x ) ;
In[12]:=
MrvLimit [ f , x ]
Out[12]=
1
In[13]:=
Limit [ f , x ]
Out[13]=
Limit [ x ( - - - x + 1 x + - x + - x 2 + 1 x ) , x ]
MrvLimit unterstützt die Grundrechenarten +, -, , /, Potenz und Wurzel und die Funktionen Log, Gamma, LogGamma, PolyGamma, Sin, Cos, Tan, ArcSin, ArcCos, ArcTan, Sec, Csc, Cot, ArcSec, ArcCsc und ArcCot.

5.1.3 Fortgeschrittene Optionen

MrvLimit unterstützt einige fortgeschrittene Optionen. Diese Optionen können in beliebiger Reihenfolge angegeben werden.
Ausgabeformat
Mittels Output→Limit, Output→LeadTerm und Output→SignedZero kann die Ausgabe von MrvLimit verändert werden. Dabei ist Output→Limit die Standardvorgabe.

Limit[f,xlim, Output→SignedZero] gibt den Grenzwert normal aus, wenn der Grenzwert nicht 0 ist. Ist der berechnete Grenzwert 0, wird entweder Zero oder -Zero ausgegeben, je nachdem, ob in der Umgebung des Grenzwertes die Funktion positiv oder negativ ist.

Limit[f,xlim, Output→LeadTerm] gibt eine bei der Grenzwertberechnung ermittelte Asymptote aus. Die Ausgabe hat folgendes Format:

LeadTerm[const,{pwr[ base 1 ,exp 1 ],pwr[ base 2 ,exp 2 ],... pwr[ base n ,exp n ]}]

const ist der nicht von x abhängige Teil der Funktion,
base i sind exponentielle Basisfunktionen,
exp i sind die reellen, konstanten Exponenten, die die Ordnung repräsentieren, in der die Basisfunktionen auftreten.

Die zurückgegebenen Terme sind in interner Darstellung belassen, um deren spezielle Struktur zu erhalten. Durch Anwendung der Funktion FromInternal[f,x] kann die allgemeine Mathematica-Darstellung zurück gewonnen werden. Mehr zur internen Darstellung im Kapitel über Hilfsfunktionen.

Alle Basisfunktionen sind Exponentialfunktionen, sind positiv und haben für x lim, x>0 den Grenzwert 0.

Die Basisfunktionen sind dabei nach fallender Wachstumsordnung geordnet. Die erste Funktion mit exp i 0 ist dominant und bestimmt das Wachstumsverhalten der Funktion.

Die Asymptote ist dabei die Funktion const base 1 exp 1 base 2 exp 2 ⋅ ⋅ ⋅base n exp n
In[14]:=
f = - 1 x - - x + - x + - x 2 + 1 x ;
In[15]:=
lt = MrvLimit [ f , x , Output LeadTerm ]
Out[15]=
LeadTerm [ 1 , { pwr [ - x , 0 ] , pwr [ - x 2 , 0 ] , pwr [ - x , 1 ] , pwr [ - Log [ x ] , 0 ] } ]
Alle Terme, abgesehen von e - x , treten nur scheinbar auf und spielen für den Grenzwert keine Rolle.

Die Ausgabe erfolgt hier in der internen Funktionsdarstellung von MrvLimit und nicht in normaler Mathematica-Darstellung. Durch die Aufhebung der internen Darstellung wird e - log(x) wieder automatisch zu 1 x vereinfacht:
In[16]:=
lt = FromInternal [ lt , x ]
Out[16]=
LeadTerm [ 1 , { pwr [ - x , 0 ] , pwr [ - x 2 , 0 ] , pwr [ - x , 1 ] , pwr [ 1 x , 0 ] } ]
Durch Ausführung der Potenzen eliminieren sich die scheinbaren Basisfunktionen:
In[17]:=
lt = lt /. pwr Power
Out[17]=
LeadTerm [ 1 , { 1 , 1 , - x , 1 } ]
Multiplikation aller Terme ergibt die eigentliche Asymptote:
In[18]:=
lt = lt [ [ 1 ] ] * Apply [ Times , lt [ [ 2 ] ] ]
Out[18]=
- x
Die Überprüfung zeigt, dass die Asymptote gefunden ist:
In[19]:=
MrvLimit [ f / lt , x ]
Out[19]=
1
Cachekontrolle
Durch Setzen der Option ClearCache→True wird vor der Grenzwertberechnung eine Leerung des Algorithmus-internen Ergebniscache veranlasst. Jeder einmal berechnete Grenzwert wird darin aufbewahrt, um wiederholte Berechnungen des gleichen Grenzwertes zu verhindern. Eine Leerung des Caches ist erforderlich, wenn sich Rahmenbedingungen verändern, die Auswirkungen auf die Grenzwertberechnung haben:
In[20]:=
Unprotect [ Sign ] ; Sign [ a ] = 1 ; Protect [ Sign ] ;
In[21]:=
MrvLimit [ a x , x ]
Out[21]=
In[22]:=
Unprotect [ Sign ] ; Sign [ a ] = - 1 ; Protect [ Sign ] ;
In[23]:=
MrvLimit [ a x , x ]
Out[23]=
Dieses Ergebnis ist falsch, da das angenommene Vorzeichen von a Auswirkung auf den Grenzwert hat, und damit das gecachete Ergebnis keine Gültigkeit mehr hat.
In[24]:=
MrvLimit [ a x , x , ClearCache True ]
Out[24]=
0
In[25]:=
Unprotect [ Sign ] ; Sign [ a ] =. ; Protect [ Sign ] ;
Alternativ kann der Cache durch Aufruf von MrvLimitClearCache[] geleert werden.

MrvLimitGetCacheStats[] liefert eine statistische Ausgabe über den Nutzungsgrad des Caches:
In[26]:=
MrvLimitGetCacheStats [ ]
Out[26]=
{ CacheHits 52 , CacheMisses 13 }
CacheHits gibt dabei an, wie viele Grenzwertberechnungen durch gecachete Ergebnisse vermieden werden konnten, CacheMisses gibt an, wie viele Grenzwertberechnungen tatsächlich ausgeführt wurden.
Debuginformationen
Mit Debug→n wird die Debug-Ausgabe des MrvLimit-Algorithmus aktiviert. Dabei gibt n an, bis zu welcher rekursiven Schachtelungstiefe die Debuginformationen ausgegeben werden sollen. Debug→∞ gibt Debuginformationen in beliebiger Schachtelungstiefe aus.
In[27]:=
MrvLimit [ E ^ x , x , Debug 1 , ClearCache True ]
Enter Level 1 Call MrvLimitInf [ x , x , Debug ]
Calculating limit of x
Calculating Mrv set of x
Ω= { MrvF [ x , 3 , ] }
ω= x
Replacing ω→1/ω: ω= - x
Prepare to rewrite g= x to A*ω^c
c= - 1 A= 1
Rewriting x 1 ω
f= 1 ω
Calculating power series: f= 1 ω
Series expansion: 1 ω + O [ ω ] 2
Dominant term: 1 ω , ω= - x
Dominant asymptotic: 1 1 - x
Leave Level 1 Call MrvLimitInf [ x , x , Debug ] ==
Out[27]=

5.1.4 Hilfsfunktionen

ToInternal / FromInternal
MrvLimit verwendet intern eine Funktionsdarstellung, in der bestimmte Funktionen durch alternative Schreibweisen ersetzt werden. Durch diese Ersetzung werden störende Effekte durch automatische Transformationen vermieden. MrvLimit übersetzt die Eingabe und Ausgabe automatisch in die interne Darstellung und zurück. Nur bei einigen fortgeschrittenen Eingriffsmöglichkeiten trifft man auf die interne Darstellung.

Funktionen und ihre interne Darstellung in MrvLimit:

FunktionDarstellung
Powerpower
Loglog
Sinsin
Coscos
Tantan
ArcSinarcsin
ArcCosarccos
ArcTanarctan
Gammagamma
LogGammaloggamma
PolyGammapolygamma


Die Anzeige der Funktionen durch Mathematica entspricht jeweils der normalen Anzeige:
In[28]:=
power [ E , x ] + Power [ E , x ]
Out[28]=
x + x
Zur Konvertierung zwischen Mathematica-Darstellung und normaler Darstellung dienen die Hilfsfunktionen ToInternal[f,x] und FromInternal[f,x]:
In[29]:=
f = ToInternal [ E ^ x * Sin [ x ] ^ c , x ]
Out[29]=
x Sin [ x ] c
In[30]:=
f = f /. c 0
Out[30]=
x Sin [ x ] 0
In[31]:=
FromInternal [ f , x ]
Out[31]=
x
ToInternal verarbeitet nur Funktionen, die für den Algorithmus als bekannt gelten:
In[32]:=
ToInternal [ Foo [ x ] , x ]
MrvLimit :: UnsupportedFunction : MrvLimit does not support this function: Foo [ x ]
Out[32]=
ToInternal [ Foo [ x ] , x ]

5.1.5 Erweiterungsschnittstellen

Potenzreihen
MrvLimit ist abhängig von einem guten Algorithmus zur Potenzreihenentwicklung, kann selbst aber nur auf die beschränkten Möglichkeiten des Series-Kommandos von Mathematica zurückgreifen. Oft genügt aber schon eine kleine Modifikation an der auftretenden Funktion, um die Potenzreihe zu ermitteln. Oder es steht ein gänzlich anderer Algorithmus zur Potenzreihenentwicklung zur Verfügung. Über die Variable $MrvSeriesHead kann eine solche Methode eingebunden werden:
In[33]:=
MrvLimit [ ( x x ) 1 x , x ]
MrvLimit :: SeriesFail : Series failed at Log [ x ω ] x
Out[33]=
MrvLimit [ ( x x ) 1 x , x ]
In[34]:=
SeriesHelper [ f_ , x_ , ω_ , logω_ , dprint_ ] := Module [ { } , If [ FromInternal [ f , x ] === ( x ω ) 1 x , Return [ { ToInternal [ 1 + Log [ x ] x , x ] , 0 } ] ; ] ; MrvSeriesHead [ f , x , ω , logω , dprint ] ] ;
In[35]:=
MrvSeriesHead = SeriesHelper ;
In[36]:=
res = MrvLimit [ ( x x ) 1 x , x , ClearCache True ] ;
In[37]:=
MrvSeriesHead = MrvSeriesHead ;
In[38]:=
res
Out[38]=
Für die genaue Implementierung der Schnittstelle sollte der Quelltext der Funktion MrvSeriesHead herangezogen werden.
Nulltests
Genau wie das Series-Kommando von Mathematica sind auch die Nulltests eine kritische Schwäche des Algorithmus. Auch sie können einfach ersetzt werden. $MrvTestZero verweist auf eine Funktion, die zum Testen von Termen auf den Wert 0 verwendet wird. Die Standardvorgabe ist $MrvTestZero = MrvTestZero mit:

MrvTestZero[term_,x_] := Simplify[FromInternal[term,x] == 0];

Alternativ bietet sich die schnellere, aber ungenauere folgende Variante an:
FromInternal[term,x] == 0,
oder die gründlichere, aber erheblich langsamere folgende Variante :
Simplify[FromInternal[term, x] == 0, Element[x, Reals]]
Mathematica steuert außerdem noch die folgende Variante bei:
Developer`ZeroQ[FromInternal[term, x]]

Um Funktionen in der Umgebung eines Grenzwertes (normalerweise ∞) auf die Nullfunktion zu testen, wird $MrvTestZeroInterval verwendet. Die Standardvorgabe ist hierbei $MrvTestZeroInterval = MrvTestZeroInterval, definiert als:

MrvTestZeroInterval[term_,x_→∞] := Simplify[FromInternal[term, x] == 0];

Neben den bereits genannten Varianten kann hier auch die konkrete Umgebung berücksichtigt werden, zum Beispiel mit Simplify[FromInternal[term, x] == 0, x > 10 1000 ]. Leider ist auch dieser Aufruf mit unkalkulierbaren Laufzeiten verbunden, weshalb als Standard nur ein einfacher Nulltest ohne Bezug auf x durchgeführt wird.
Debugausgabe
Falls man an einer anderen Ausgabeform der Debug-Option interessiert ist, kann man diese über $DebugPrint bekannt machen:
In[39]:=
MyPrint [ Indent_ , Text__ ] := Print [ Debug[ , Indent , ]: , Text ] ;
In[40]:=
DebugPrint = MyPrint ;
In[41]:=
MrvLimit [ E ^ x , x , Debug 1 ] ;
In[42]:=
DebugPrint = IndentPrint ;
Debug[ 0 ]: Enter Level 1 Call MrvLimitInf [ x , x , Debug 1 ]
Debug[ 0 ]: Taking cached result
Debug[ 0 ]: Leave Level 1 Call MrvLimitInf [ x , x , Debug 1 ] ==
Ausgabesteuerung
Da die Ausgabe von Funktionsteilen und die Debugausgabe sehr umfangreich sein kann, ist es u.U. sinnvoll, solche Ausgaben zu filtern. Mit der Variable $OutputProcessor kann jede Debugausgabe und jede Meldungsausgabe nachbearbeitet werden:
In[43]:=
f = h - x + h - x 1 + h /. h -> 1 1 + - x ;
In[44]:=
OutputProcessor = ( FromInternal [ # , x ] /. { 1 1 + - x h } & ) ;
In[45]:=
MrvLimit [ f , x , Debug 1 , ClearCache True ] ;
In[46]:=
OutputProcessor = Identity ;
Enter Level 1 Call MrvLimitInf [ - x + h + h - x 1 + h , x , Debug 1 ]
Calculating limit of h - x + h - x 1 + h
Calculating Mrv set of h - x + h - x 1 + h
Ω= { MrvF [ - x , 5 , 0 ] , MrvF [ h - x , 15 , 0 ] , MrvF [ h - x + h - x 1 + h , 43 , 0 ] }
ω= - x
Prepare to rewrite g= h - x + h - x 1 + h to A*ω^c
c= 1 2 A= h - x + h + x 2 - x 1 + h
Rewriting h - x + h - x 1 + h h - x + h + x 2 - x 1 + h ω
f= h - x + h + x 2 - x 1 + h ω
Prepare to rewrite g= h - x to A*ω^c
c= 1 A= h
Rewriting h - x h ω
f= h + x 2 - x 1 + h + h ω ω
Prepare to rewrite g= - x to A*ω^c
c= 1 A= 1
Rewriting - x ω
f= x 2 + 1 1 + ω ω + 1 1 + ω - x 1 + 1 1 + ω ω
Calculating power series: f= x 2 + 1 1 + ω ω + 1 1 + ω - x 1 + 1 1 + ω ω
Series expansion: ω + O [ ω ] 3 / 2
Dominant term: ω , ω= - x
Dominant asymptotic: - x
Leave Level 1 Call MrvLimitInf [ - x + h + h - x 1 + h , x , Debug 1 ] == 0

Zurück - Inhalt - Übersicht - Vorwärts
Zurück - Inhalt - Übersicht - Vorwärts